Merge commit '7e675e7beb25a8ddcb3f6cc6f0101f0ffd668e1e' into HEAD

The email-connection feature was whole on the server and unreachable in the
product. `ticketing_email_connections` has shipped since 2026_04_08_000008,
the three write routes are live and healthy — an empty POST answers a 422
validation bag — and index() has been computing an `emailConnections` prop on
EVERY settings render. The one thing missing was the segment that lets
somebody look at it: `email` was not in the `{tab}` whitelist, so the only
deep link anybody could guess fell through to the POST-only `/settings/email`
and answered 405 while its five siblings answered 200.

The segment is in the whitelist now, and the shell's Settings.vue grows the
tab that renders the prop (dashboard-shell, same branch).

Two things about the prop had to change before a UI could read it:

  · the stored mailbox PASSWORD no longer leaves the server. It was sitting in
    `config` on a prop that ships to everyone who can open Help Desk Settings;
    nothing rendered it before, so nothing is lost by shaping the rows by hand
    and sending `has_password` instead of the credential.

  · a save with the password box blank KEEPS the stored password. The form
    cannot prefill a password it is never sent, so an empty box has to mean
    "unchanged" — otherwise correcting a host would silently disconnect the
    mailbox, and the row would still read as configured.

Proof: tests/Feature/Ticketing/EmailConnectionsHaveADoorTest.php (shell) —
17 tests, including every tab key read out of the Vue's own TAB_KEYS and
asserted 200.

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

composer.json

@@ -1,7 +1,7 @@
 {
     "name": "dashboard/ticketing",
     "description": "Help desk ticketing snap-in for the Dashboard platform",
-    "version": "1.0.1",
+    "version": "1.0.4",
     "type": "library",
     "require": {
         "php": "^8.2",
@@ -19,6 +19,8 @@
             "providers": ["Dashboard\\Ticketing\\TicketingServiceProvider"]
         },
         "dashboard": {
+            "tier": "optional",
+            "stability": "beta",
             "nav_folder": {
                 "label": "Help Desk",
                 "icon": "ticket",

config/ticketing.php

@@ -0,0 +1,15 @@
+<?php
+
+return [
+
+    /*
+     * The filesystem disk ticket attachments are stored on. Read at runtime via
+     * config('ticketing.storage_disk') — NOT env() — so it survives config:cache
+     * in production. Before this file existed the controllers read
+     * env('TICKETING_STORAGE_DISK') directly, which returns null once the config
+     * is cached, silently forcing every attachment onto the 'local' disk and
+     * orphaning anything an operator had pointed elsewhere (secrets spec S3).
+     */
+    'storage_disk' => env('TICKETING_STORAGE_DISK', 'local'),
+
+];

database/migrations/2026_07_26_000001_add_archived_at_to_ticketing_groups.php

@@ -0,0 +1,38 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+/**
+ * Groups can be retired without destroying ticket history.
+ *
+ * A group may own tickets, and tickets are the audit record of real
+ * correspondence — so "delete this group" can only ever hard-delete when the
+ * group is empty. When it owns tickets we archive instead, and archiving needs
+ * somewhere to record itself.
+ *
+ * Expand-only: one nullable timestamp added to an existing table. Nothing is
+ * dropped, renamed or backfilled, and every existing row keeps its meaning
+ * (NULL = active), so the old code path reads this table unchanged. That is
+ * what keeps the trunk deployable — see `php artisan dashboard:doctor`.
+ */
+return new class extends Migration
+{
+    public function up(): void
+    {
+        Schema::table('ticketing_groups', function (Blueprint $table) {
+            $table->timestamp('archived_at')->nullable()->after('prefix');
+        });
+    }
+
+    public function down(): void
+    {
+        // Deliberate NO-OP, matching the warnings-column precedent in
+        // dashboard-myedpuller-sync: DashboardDoctor greps the WHOLE migration file
+        // for drop/rename patterns, so a dropColumn even in down() raises the
+        // "pending destructive migration" advisory on every host where this is
+        // still pending — a confusing warning for a purely additive change. A
+        // nullable column costs nothing to leave behind.
+    }
+};

database/migrations/2026_08_27_000001_add_ticket_number_sequence_to_ticketing_groups.php

@@ -0,0 +1,82 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Schema;
+
+/**
+ * A ticket reference must never be issued twice.
+ *
+ * `TicketingGroup::nextTicketNumber()` derived the next reference from the MAX
+ * suffix over the group's **live** tickets. Tickets are hard-deleted (no
+ * SoftDeletes on the model), so deleting the newest ticket in a group put the
+ * number back in the pool and the next ticket was issued the same reference —
+ * two different tickets both carrying `QAX-0004`.
+ *
+ * That matters well outside Ticketing, because the reference is the correlation
+ * key that leaves the app: it is the `[QAX-0004]` token in outbound mail subject
+ * lines, so a reply can thread onto the wrong ticket; the shell Notification Log
+ * is an audit trail keyed on that subject; and `TicketController::merge()` looks
+ * a ticket up by `number` and takes `->first()`, so a duplicate makes it merge
+ * into an arbitrary one of the two.
+ *
+ * This column is that pool: a per-group high-water mark that only ever goes up,
+ * independent of whether the ticket it was issued to still exists.
+ *
+ * **The backfill is the load-bearing half of this migration.** Left at 0, the
+ * first ticket created after deploy would be issued `-0001` on a group that has
+ * been running for months — turning a bug that reused one number into one that
+ * reuses every number. So each group is seeded with the same MAX the old code
+ * would have read, scoped to its CURRENT prefix exactly as the old query was.
+ * The next reference issued after this migration is therefore identical to the
+ * one the old code would have issued; all that changes is that it can no longer
+ * go backwards afterwards.
+ *
+ * Expand-only: one column added with a default, nothing dropped or renamed, and
+ * existing rows keep their meaning. Note there is deliberately NO unique index
+ * on `tickets.number` — production already contains duplicates created by this
+ * bug (the report evidences at least `QAX-0001`–`QAX-0004`), so adding one here
+ * would fail the deploy. De-duplicating the existing rows is its own decision,
+ * with its own migration, and is not made silently here.
+ */
+return new class extends Migration
+{
+    public function up(): void
+    {
+        if (! Schema::hasColumn('ticketing_groups', 'last_ticket_number')) {
+            Schema::table('ticketing_groups', function (Blueprint $table) {
+                $table->unsignedInteger('last_ticket_number')->default(0)->after('prefix');
+            });
+        }
+
+        // Seed the high-water mark from the numbers already issued. Same shape as
+        // the query this replaces: the group's own tickets, restricted to its
+        // current prefix, suffix cast to an integer.
+        foreach (DB::table('ticketing_groups')->select('id', 'prefix')->get() as $group) {
+            $prefix = $group->prefix.'-';
+
+            $max = (int) DB::table('tickets')
+                ->where('group_id', $group->id)
+                ->where('number', 'like', $prefix.'%')
+                ->max(DB::raw('CAST(SUBSTRING(number, '.(strlen($prefix) + 1).') AS UNSIGNED)'));
+
+            // Never lower a counter that already holds a larger value — this
+            // migration must be safe to re-run and must never hand back a number.
+            DB::table('ticketing_groups')
+                ->where('id', $group->id)
+                ->where('last_ticket_number', '<', $max)
+                ->update(['last_ticket_number' => $max]);
+        }
+    }
+
+    public function down(): void
+    {
+        // Deliberate NO-OP, matching the archived_at precedent above it:
+        // DashboardDoctor greps the whole migration file for drop/rename patterns,
+        // so a dropColumn even in down() raises "pending destructive migration" on
+        // every host where this is still pending. An integer column with a default
+        // costs nothing to leave behind — and dropping it would silently restore
+        // the reference-reuse bug.
+    }
+};

database/migrations/2026_08_29_000001_a_system_note_is_a_ticket_message_source.php

@@ -0,0 +1,66 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Support\Facades\DB;
+
+/**
+ * MERGE AND SPLIT WROTE A `source` THE COLUMN DID NOT ACCEPT.  [central-ticketing] #415
+ *
+ * Both actions write an audit note into `ticket_messages` with `source = 'system'`,
+ * and the column was created as `enum('web','email')`. Under strict mode the insert
+ * throws `Data truncated for column 'source'` INSIDE the transaction, so nothing
+ * commits: no merge, no split, no partial state, and a generic 500 page. Every
+ * guard around them worked — a missing reference, a self-merge and an absent
+ * `source_number` were all handled correctly — so only the happy path was broken,
+ * which is why it survived.
+ *
+ * ── THE WHOLE DOMAIN, NOT THE ONE IN THE TRACE ──────────────────────────────
+ *
+ * The trace named `'system'`. Widening to accept only that would be a guess about
+ * how many more there are, so every value written to this column anywhere in the
+ * platform was enumerated first:
+ *
+ *   'web'     TicketMessageController::store(), the demo seeder
+ *   'email'   the demo seeder (no inbound-mail ingester exists yet)
+ *   'system'  TicketController::merge() and ::split(), the three notes
+ *
+ * `split()` also copies `$msg->source` verbatim when duplicating a thread, which
+ * introduces no fourth value. So the set is closed at three and this runs once.
+ *
+ * ── WHY AN ENUM AND NOT A VARCHAR ───────────────────────────────────────────
+ *
+ * `tickets.status` went the other way — `2026_04_17_000002` deliberately widened it
+ * from an enum to `varchar(50)` — and the difference is the test worth writing down:
+ * statuses became OPERATOR-DEFINABLE rows in `ticketing_statuses`, so no enum could
+ * ever hold them. `source` is the opposite: all three values are set by code, an
+ * operator has no way to add a fourth, and the enum is what makes a typo'd source a
+ * loud failure rather than a silently unfilterable row.
+ *
+ * The write side is bounded too — `TicketMessage::system()` is now the only place a
+ * system note is created, so the three scattered `'source' => 'system'` literals that
+ * caused this cannot reappear one at a time.
+ */
+return new class extends Migration
+{
+    public function up(): void
+    {
+        DB::statement(
+            "ALTER TABLE ticket_messages
+             MODIFY COLUMN source ENUM('web','email','system') NOT NULL DEFAULT 'web'"
+        );
+    }
+
+    public function down(): void
+    {
+        // Rewrite the rows first: narrowing an enum that still holds 'system' turns
+        // those rows into the empty string rather than failing, which would leave the
+        // merge and split notes present but unattributable. 'web' is the honest
+        // fallback — they were written by a person pressing a button in the app.
+        DB::table('ticket_messages')->where('source', 'system')->update(['source' => 'web']);
+
+        DB::statement(
+            "ALTER TABLE ticket_messages
+             MODIFY COLUMN source ENUM('web','email') NOT NULL DEFAULT 'web'"
+        );
+    }
+};

database/migrations/2026_09_04_000001_repair_inconsistent_merged_tickets.php

@@ -0,0 +1,73 @@
+<?php
+
+use Dashboard\Ticketing\Support\MergedTicketRepair;
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Support\Facades\Log;
+
+/**
+ * OPTION A OF [central-ticketing] #938 — the repair, behind a setting that is OFF.
+ *
+ * The rows the merge bug minted (`merged_into_id` set, `status` back to `open`)
+ * are data, not code, and #920 deliberately shipped no data change. This
+ * migration is the one that would: it re-marks every such row `merged`, which
+ * makes it read-only under #920's guard, and it leaves every message,
+ * participant and field edit made after the merge exactly where it is.
+ *
+ * IT DOES NOT RUN UNLESS THE OPERATOR HAS ASKED. `MergedTicketRepair::SETTING`
+ * — "auto-repair inconsistent merged tickets on deploy" — defaults off, and a
+ * box that has never heard of it therefore deploys this migration and changes
+ * nothing at all. That is what lets the code ship ahead of the decision: the
+ * office gets the badge and the one-click fix now (option B), and turning this
+ * on is the operator's separate, later, reversible act (option C).
+ *
+ * WHAT IT ALWAYS DOES, EITHER WAY, IS COUNT AND SAY SO. The dry-run count goes
+ * to the log on every deploy whether the repair is armed or not, because the
+ * number is the thing #938 was blocked on and a deploy is the one moment
+ * something is definitely looking at prod's database.
+ */
+return new class extends Migration
+{
+    public function up(): void
+    {
+        // The dry run, first and unconditionally.
+        $count = MergedTicketRepair::count();
+
+        Log::info(sprintf(
+            '[ticketing] #938 dry run: %d ticket(s) have merged_into_id set with a status other than "merged".',
+            $count,
+        ));
+
+        if ($count === 0) {
+            return;
+        }
+
+        if (! MergedTicketRepair::enabledOnDeploy()) {
+            Log::info(sprintf(
+                '[ticketing] #938: leaving those %d row(s) editable — "%s" is off. '
+                .'Turn it on in Ticketing → Settings → Automation, or fix them one at a '
+                .'time with the "Mark merged" button on each ticket.',
+                $count,
+                MergedTicketRepair::SETTING,
+            ));
+
+            return;
+        }
+
+        MergedTicketRepair::repairAll('migration 2026_09_04_000001');
+    }
+
+    /**
+     * There is no down migration, and that is a decision rather than an omission.
+     *
+     * Reverting would mean putting each row's status back to what it was before
+     * the bad save, and nothing anywhere records what that was — the bug
+     * overwrote it. Setting them all back to `open` would not be a rollback; it
+     * would be re-creating the corrupt shape on rows that may have been merged
+     * legitimately years ago. A row repaired in error is corrected the same way
+     * any other status is: an agent edits the ticket.
+     */
+    public function down(): void
+    {
+        // Intentionally empty — see the note above.
+    }
+};

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');
+        });
+    }
+};

resources/js/Pages/Ticketing/Create.vue

@@ -1,131 +0,0 @@
-<template>
-  <AppLayout>
-    <div class="max-w-2xl mx-auto">
-      <div class="mb-6">
-        <Link :href="route('ticketing.index')" class="text-sm text-indigo-600 hover:underline">← Back to tickets</Link>
-        <h1 class="text-2xl font-bold text-gray-900 mt-2">Submit a Ticket</h1>
-      </div>
-
-      <!-- Bootstrap / No groups state -->
-      <div v-if="isBootstrap" class="bg-amber-50 border border-amber-300 rounded-xl px-5 py-6 text-center">
-        <p class="text-amber-800 font-semibold text-base mb-2">📦 Ticketing isn't set up yet</p>
-        <p class="text-sm text-amber-700 mb-4">An admin needs to create at least one group before tickets can be submitted.</p>
-        <Link v-if="isSiteAdmin" :href="route('ticketing.settings')" class="inline-block bg-indigo-600 text-white text-sm px-4 py-2 rounded-lg hover:bg-indigo-700">Go to Settings</Link>
-      </div>
-
-      <form v-else @submit.prevent="submit" class="bg-white rounded-xl shadow-sm border border-gray-200 p-6 space-y-5">
-        <!-- Group -->
-        <div>
-          <label class="block text-sm font-medium text-gray-700 mb-1">Group <span class="text-red-500">*</span></label>
-          <select
-            v-model="form.group_id"
-            required
-            class="w-full border-gray-300 rounded-lg text-sm"
-          >
-            <option value="">Select a group</option>
-            <option v-for="g in groups" :key="g.id" :value="g.id">{{ g.name }}</option>
-          </select>
-          <p v-if="form.errors.group_id" class="text-xs text-red-600 mt-1">{{ form.errors.group_id }}</p>
-        </div>
-
-        <!-- Title -->
-        <div>
-          <label class="block text-sm font-medium text-gray-700 mb-1">Title <span class="text-red-500">*</span></label>
-          <input
-            v-model="form.title"
-            type="text"
-            required
-            placeholder="Brief summary of the issue"
-            class="w-full border-gray-300 rounded-lg text-sm"
-          />
-          <p v-if="form.errors.title" class="text-xs text-red-600 mt-1">{{ form.errors.title }}</p>
-        </div>
-
-        <!-- Description -->
-        <div>
-          <label class="block text-sm font-medium text-gray-700 mb-1">Description <span class="text-red-500">*</span></label>
-          <textarea
-            v-model="form.description"
-            required
-            rows="5"
-            placeholder="Describe the issue in detail..."
-            class="w-full border-gray-300 rounded-lg text-sm"
-          ></textarea>
-          <p v-if="form.errors.description" class="text-xs text-red-600 mt-1">{{ form.errors.description }}</p>
-        </div>
-
-        <!-- Priority -->
-        <div>
-          <label class="block text-sm font-medium text-gray-700 mb-1">Priority</label>
-          <select
-            v-model="form.priority_id"
-            class="w-full border-gray-300 rounded-lg text-sm"
-          >
-            <option :value="null">No priority</option>
-            <option v-for="p in filteredPriorities" :key="p.id" :value="p.id">{{ p.name }}</option>
-          </select>
-        </div>
-
-        <!-- Due Date -->
-        <div>
-          <label class="block text-sm font-medium text-gray-700 mb-1">Due Date <span class="text-gray-400 font-normal">(optional)</span></label>
-          <input
-            v-model="form.due_date"
-            type="date"
-            class="w-full border-gray-300 rounded-lg text-sm"
-          />
-        </div>
-
-        <!-- Submit -->
-        <div class="flex justify-end pt-2">
-          <button
-            type="submit"
-            :disabled="form.processing"
-            class="inline-flex items-center gap-2 bg-gray-900 text-white px-5 py-2 rounded-lg text-sm font-medium hover:bg-gray-700 disabled:opacity-60 transition"
-          >
-            <span v-if="form.processing">Submitting…</span>
-            <span v-else>Submit Ticket</span>
-          </button>
-        </div>
-      </form>
-    </div>
-  </AppLayout>
-</template>
-
-<script setup>
-import { computed, watch } from 'vue'
-import { Link, useForm } from '@inertiajs/vue3'
-import AppLayout from '@/Layouts/AppLayout.vue'
-
-const props = defineProps({
-  groups: Array,
-  priorities: Array,
-  isBootstrap: Boolean,
-  isSiteAdmin: Boolean,
-})
-
-const form = useForm({
-  group_id: '',
-  title: '',
-  description: '',
-  priority_id: null,
-  due_date: '',
-})
-
-const filteredPriorities = computed(() => {
-  if (!form.group_id) return props.priorities.filter(p => !p.group_id)
-  return props.priorities.filter(p => !p.group_id || p.group_id === Number(form.group_id))
-})
-
-// Reset priority if it's no longer valid for the newly selected group
-watch(() => form.group_id, () => {
-  const valid = filteredPriorities.value.some(p => p.id === form.priority_id)
-  if (!valid) {
-    form.priority_id = null
-  }
-})
-
-function submit() {
-  form.post(route('ticketing.store'))
-}
-</script>

resources/js/Pages/Ticketing/Edit.vue

@@ -1,117 +0,0 @@
-<template>
-  <AppLayout>
-    <div class="max-w-2xl mx-auto">
-      <div class="mb-6">
-        <Link :href="route('ticketing.show', { ticket: ticket.id })" class="text-sm text-indigo-600 hover:underline">← Back to ticket</Link>
-        <h1 class="text-xl font-bold text-gray-900 mt-2">
-          Edit <span class="font-mono text-base">{{ ticket.number }}</span>
-        </h1>
-      </div>
-
-      <form @submit.prevent="submit" class="bg-white rounded-xl shadow-sm border border-gray-200 p-6 space-y-5">
-        <!-- Title -->
-        <div>
-          <label class="block text-sm font-medium text-gray-700 mb-1">Title</label>
-          <input v-model="form.title" type="text" required class="w-full border-gray-300 rounded-lg text-sm" />
-          <p v-if="form.errors.title" class="text-xs text-red-600 mt-1">{{ form.errors.title }}</p>
-        </div>
-
-        <!-- Description -->
-        <div>
-          <label class="block text-sm font-medium text-gray-700 mb-1">Description</label>
-          <textarea v-model="form.description" rows="6" required class="w-full border-gray-300 rounded-lg text-sm"></textarea>
-          <p v-if="form.errors.description" class="text-xs text-red-600 mt-1">{{ form.errors.description }}</p>
-        </div>
-
-        <!-- Status -->
-        <div>
-          <label class="block text-sm font-medium text-gray-700 mb-1">Status</label>
-          <select v-model="form.status" class="w-full border-gray-300 rounded-lg text-sm">
-            <option value="open">Open</option>
-            <option value="in_progress">In Progress</option>
-            <option value="pending">Pending</option>
-            <option value="resolved">Resolved</option>
-            <option value="closed">Closed</option>
-          </select>
-        </div>
-
-        <!-- Priority -->
-        <div>
-          <label class="block text-sm font-medium text-gray-700 mb-1">Priority</label>
-          <select v-model="form.priority_id" class="w-full border-gray-300 rounded-lg text-sm">
-            <option :value="null">No priority</option>
-            <option v-for="p in priorities" :key="p.id" :value="p.id">{{ p.name }}</option>
-          </select>
-        </div>
-
-        <!-- Assignee -->
-        <div>
-          <label class="block text-sm font-medium text-gray-700 mb-1">Assignee</label>
-          <select v-model="form.assigned_to" class="w-full border-gray-300 rounded-lg text-sm">
-            <option :value="null">Unassigned</option>
-            <option v-for="a in agents" :key="a.id" :value="a.id">{{ a.name }}</option>
-          </select>
-        </div>
-
-        <!-- Project -->
-        <div>
-          <label class="block text-sm font-medium text-gray-700 mb-1">Project</label>
-          <select v-model="form.project_id" class="w-full border-gray-300 rounded-lg text-sm">
-            <option :value="null">No project</option>
-            <option v-for="proj in projects" :key="proj.id" :value="proj.id">{{ proj.name }}</option>
-          </select>
-        </div>
-
-        <!-- Due Date -->
-        <div>
-          <label class="block text-sm font-medium text-gray-700 mb-1">Due Date</label>
-          <input v-model="form.due_date" type="date" class="w-full border-gray-300 rounded-lg text-sm" />
-        </div>
-
-        <div class="flex gap-3 justify-end pt-2">
-          <Link
-            :href="route('ticketing.show', { ticket: ticket.id })"
-            class="px-4 py-2 text-sm text-gray-600 border border-gray-300 rounded-lg hover:bg-gray-50"
-          >Cancel</Link>
-          <button
-            type="submit"
-            :disabled="form.processing"
-            class="px-5 py-2 bg-gray-900 text-white text-sm font-medium rounded-lg hover:bg-gray-700 disabled:opacity-60 transition"
-          >
-            {{ form.processing ? 'Saving…' : 'Save Changes' }}
-          </button>
-        </div>
-      </form>
-    </div>
-  </AppLayout>
-</template>
-
-<script setup>
-import AppLayout from '@/Layouts/AppLayout.vue'
-import { Link, useForm } from '@inertiajs/vue3'
-
-const props = defineProps({
-  ticket: Object,
-  priorities: Array,
-  agents: Array,
-  projects: Array,
-})
-
-const form = useForm({
-  title: props.ticket.title,
-  description: props.ticket.description,
-  status: props.ticket.status,
-  priority_id: props.ticket.priority_id,
-  assigned_to: props.ticket.assigned_to,
-  project_id: props.ticket.project_id,
-  due_date: props.ticket.due_date,
-})
-
-function submit() {
-  form.put(route('ticketing.update', { ticket: props.ticket.id }), {
-    onSuccess: () => {
-      // redirect happens server side
-    }
-  })
-}
-</script>

resources/js/Pages/Ticketing/Index.vue

@@ -1,798 +0,0 @@
-<template>
-  <div class="flex flex-col lg:flex-row h-screen overflow-hidden bg-gray-100 text-gray-900">
-
-    <!-- Bootstrap / first-run state -->
-    <div v-if="isBootstrap" class="flex flex-col items-center justify-center w-full h-full text-center px-6">
-      <div class="max-w-md">
-        <div class="text-5xl mb-4">🎫</div>
-        <h2 class="text-2xl font-bold text-gray-800 mb-2">Ticketing isn’t set up yet</h2>
-        <p class="text-gray-500 mb-6">Create your first group in Settings to get started. Default priorities will be seeded automatically.</p>
-        <Link :href="route('ticketing.settings')" class="inline-block bg-indigo-600 text-white px-5 py-2.5 rounded-xl text-sm font-medium hover:bg-indigo-700 transition">Go to Settings</Link>
-      </div>
-    </div>
-
-    <template v-else>
-    <aside
-      class="min-w-0 w-full shrink-0 border-r border-gray-200 bg-white/90 backdrop-blur lg:flex lg:w-72 lg:flex-col overflow-y-auto lg:overflow-visible"
-      :class="showSidebar ? 'flex flex-col' : 'hidden'"
-    >
-      <div class="border-b border-gray-200 p-5">
-        <div class="flex items-center justify-between gap-3">
-          <div class="min-w-0 overflow-hidden">
-            <p class="text-xs font-semibold uppercase tracking-[0.22em] text-gray-400 truncate">Shared inbox</p>
-            <h1 class="mt-1 text-2xl font-semibold tracking-tight truncate">Ticketing</h1>
-          </div>
-          <div class="flex items-center gap-2">
-            <button
-              type="button"
-              class="inline-flex h-10 items-center justify-center rounded-xl border border-gray-200 px-4 text-sm font-medium text-gray-600 transition hover:bg-gray-100 lg:hidden"
-              @click="showSidebar = false"
-            >
-              Done
-            </button>
-            <Link
-              :href="route('ticketing.create')"
-              class="inline-flex h-10 items-center justify-center rounded-xl bg-gray-900 px-4 text-sm font-medium text-white transition hover:bg-gray-700:bg-indigo-400"
-            >
-              New
-            </Link>
-          </div>
-        </div>
-      </div>
-
-      <div class="flex-1 min-w-0 space-y-6 overflow-y-auto p-5">
-        <section class="space-y-2">
-          <label class="text-xs font-semibold uppercase tracking-[0.18em] text-gray-400">Group switcher</label>
-          <select
-            v-model="activeGroupId"
-            class="w-full rounded-2xl border border-gray-200 bg-gray-50 px-4 py-3 text-sm shadow-sm outline-none transition focus:border-indigo-400 focus:ring-2 focus:ring-indigo-100:border-indigo-500:ring-indigo-500/20"
-            @change="applyFilters({ group_id: normalizeNullable(activeGroupId) })"
-          >
-            <option :value="null">All groups</option>
-            <option v-for="group in groups" :key="group.id" :value="group.id">{{ group.name }}</option>
-          </select>
-        </section>
-
-        <section class="space-y-2">
-          <div class="flex items-center justify-between">
-            <h2 class="text-xs font-semibold uppercase tracking-[0.18em] text-gray-400">Views</h2>
-            <span class="text-xs text-gray-400">{{ filteredTickets.length }}</span>
-          </div>
-
-          <button
-            v-for="view in visibleViews"
-            :key="view.key"
-            type="button"
-            class="flex w-full items-center justify-between rounded-2xl px-3 py-3 text-sm transition"
-            :class="currentFilter === view.key
-              ? 'bg-gray-900 text-white shadow-sm'
-              : 'text-gray-600 hover:bg-gray-100:bg-gray-800'"
-            @click="applyFilters({ filter: view.key === 'all' ? 'all' : view.key })"
-          >
-            <span>{{ view.label }}</span>
-            <span
-              class="rounded-full px-2 py-0.5 text-xs"
-              :class="currentFilter === view.key ? 'bg-white/15 text-white' : 'bg-gray-200 text-gray-600'"
-            >
-              {{ viewCount(view.key) }}
-            </span>
-          </button>
-        </section>
-
-        <section class="space-y-3">
-          <div class="flex items-center justify-between">
-            <h2 class="text-xs font-semibold uppercase tracking-[0.18em] text-gray-400">Priority</h2>
-            <button
-              v-if="filters.priority_id"
-              type="button"
-              class="text-xs text-gray-400 transition hover:text-gray-600:text-gray-200"
-              @click="applyFilters({ priority_id: undefined })"
-            >
-              Clear
-            </button>
-          </div>
-
-          <div class="flex flex-wrap gap-2">
-            <button
-              v-for="priority in priorities"
-              :key="priority.id"
-              type="button"
-              class="inline-flex items-center gap-2 rounded-full border px-3 py-1.5 text-xs font-medium transition"
-              :class="Number(filters.priority_id) === priority.id ? 'shadow-sm' : 'border-gray-200 text-gray-600 hover:bg-gray-100:bg-gray-800'"
-              :style="priorityChipStyle(priority, Number(filters.priority_id) === priority.id)"
-              @click="togglePriority(priority.id)"
-            >
-              <span class="h-2.5 w-2.5 rounded-full" :style="{ backgroundColor: priority.color || '#94a3b8' }"></span>
-              {{ priority.name }}
-            </button>
-          </div>
-        </section>
-
-        <section class="space-y-3">
-          <div class="flex items-center justify-between">
-            <h2 class="text-xs font-semibold uppercase tracking-[0.18em] text-gray-400">Projects</h2>
-            <button
-              v-if="filters.project_id"
-              type="button"
-              class="text-xs text-gray-400 transition hover:text-gray-600:text-gray-200"
-              @click="applyFilters({ project_id: undefined })"
-            >
-              Clear
-            </button>
-          </div>
-
-          <div class="space-y-1">
-            <button
-              type="button"
-              class="flex w-full items-center justify-between rounded-2xl px-3 py-2.5 text-sm transition"
-              :class="!filters.project_id ? 'bg-gray-100 text-gray-900' : 'text-gray-600 hover:bg-gray-100:bg-gray-800'"
-              @click="applyFilters({ project_id: undefined })"
-            >
-              <span>All projects</span>
-              <span class="text-xs text-gray-400">{{ totalProjectCount }}</span>
-            </button>
-
-            <button
-              v-for="project in projects"
-              :key="project.id"
-              type="button"
-              class="flex w-full items-center justify-between rounded-2xl px-3 py-2.5 text-sm transition"
-              :class="Number(filters.project_id) === project.id ? 'bg-gray-100 text-gray-900' : 'text-gray-600 hover:bg-gray-100:bg-gray-800'"
-              @click="applyFilters({ project_id: Number(filters.project_id) === project.id ? undefined : project.id })"
-            >
-              <span class="truncate">{{ project.name }}</span>
-              <span class="rounded-full bg-gray-200 px-2 py-0.5 text-xs text-gray-600">{{ project.ticket_count ?? 0 }}</span>
-            </button>
-          </div>
-        </section>
-      </div>
-    </aside>
-
-    <main
-      class="min-w-0 w-full flex-1 border-r border-gray-200 bg-white xl:max-w-[34rem]"
-      :class="showList ? 'flex' : 'hidden lg:flex'"
-    >
-      <div class="flex min-w-0 flex-1 flex-col">
-        <div class="border-b border-gray-200 p-5">
-          <div class="flex items-center justify-between gap-3">
-            <div class="min-w-0 flex-1">
-              <p class="text-xs font-semibold uppercase tracking-[0.18em] text-gray-400">Queue</p>
-              <h2 class="mt-1 text-xl font-semibold tracking-tight">{{ currentViewTitle }}</h2>
-            </div>
-            <div class="flex items-center gap-2">
-              <button
-                type="button"
-                class="inline-flex h-10 items-center justify-center rounded-xl border border-gray-200 px-4 text-sm font-medium text-gray-600 transition hover:bg-gray-100 lg:hidden"
-                @click="showSidebar = true"
-              >
-                Filters
-              </button>
-              <Link
-                :href="route('ticketing.create')"
-                class="inline-flex h-10 items-center justify-center rounded-xl bg-gray-900 px-4 text-sm font-medium text-white transition hover:bg-gray-700 lg:hidden"
-              >
-                New
-              </Link>
-              <div class="hidden rounded-full border border-gray-200 px-3 py-1 text-xs text-gray-500 sm:block">
-                {{ tickets.total }} total
-              </div>
-            </div>
-          </div>
-
-          <div class="mt-3 text-xs text-gray-500 sm:hidden">
-            {{ tickets.total }} total
-          </div>
-
-          <div class="mt-4 flex flex-col gap-3 sm:flex-row">
-            <div class="relative flex-1">
-              <input
-                v-model="search"
-                type="text"
-                placeholder="Search tickets, people, or numbers"
-                class="w-full rounded-2xl border border-gray-200 bg-gray-50 px-4 py-3 text-sm outline-none transition focus:border-indigo-400 focus:ring-2 focus:ring-indigo-100:border-indigo-500:ring-indigo-500/20"
-              />
-            </div>
-            <select
-              v-model="sortBy"
-              class="rounded-2xl border border-gray-200 bg-gray-50 px-4 py-3 text-sm outline-none transition focus:border-indigo-400 focus:ring-2 focus:ring-indigo-100:border-indigo-500:ring-indigo-500/20"
-            >
-              <option value="newest">Newest first</option>
-              <option value="oldest">Oldest first</option>
-              <option value="priority">Priority</option>
-              <option value="status">Status</option>
-            </select>
-          </div>
-        </div>
-
-        <div class="min-h-0 flex-1 overflow-y-auto">
-          <div v-if="filteredTickets.length === 0" class="flex h-full flex-col items-center justify-center px-6 text-center">
-            <div class="rounded-3xl border border-dashed border-gray-300 px-8 py-10">
-              <p class="text-sm font-medium text-gray-500">Nothing matches the current filters.</p>
-              <p class="mt-2 text-sm text-gray-400">Try a different view, search, or priority chip.</p>
-            </div>
-          </div>
-
-          <button
-            v-for="ticket in filteredTickets"
-            :key="ticket.id"
-            type="button"
-            class="flex w-full gap-4 border-b border-gray-100 px-4 py-4 text-left transition hover:bg-gray-50 dark:hover:bg-gray-900/60 sm:px-5"
-            :class="selectedTicketId === ticket.id ? 'bg-indigo-50/80' : ''"
-            @click="selectTicket(ticket.id)"
-          >
-            <div class="w-1 self-stretch rounded-full" :style="{ backgroundColor: ticket.priority?.color || ticket.group?.color || '#cbd5e1' }"></div>
-
-            <div class="min-w-0 flex-1">
-              <div class="flex items-center gap-2">
-                <span class="text-xs font-semibold uppercase tracking-[0.12em] text-gray-400">{{ ticket.number }}</span>
-                <span :class="badgeClass(ticket.status)" class="inline-flex rounded-full px-2 py-0.5 text-[11px] font-semibold">{{ statusLabel(ticket.status) }}</span>
-                <span v-if="hasUnread(ticket)" class="h-2.5 w-2.5 rounded-full bg-sky-500"></span>
-              </div>
-
-              <p class="mt-2 truncate text-sm font-semibold text-gray-900">{{ ticket.title }}</p>
-
-              <div class="mt-3 flex items-center gap-3 text-xs text-gray-500">
-                <div class="flex items-center gap-2">
-                  <span class="avatar-ring bg-gray-200 text-gray-700">{{ initials(ticket.submitter?.name || ticket.submitter?.email || '?') }}</span>
-                  <span class="truncate">{{ ticket.submitter?.name || ticket.submitter?.email || 'Unknown' }}</span>
-                </div>
-                <span>•</span>
-                <span>{{ ageLabel(ticket.created_at) }}</span>
-              </div>
-            </div>
-
-            <div class="flex shrink-0 flex-col items-end justify-between gap-3">
-              <div class="text-xs font-medium text-gray-500 truncate max-w-[7rem]">{{ ticket.priority?.name || 'No priority' }}</div>
-              <div class="flex items-center gap-2">
-                <span class="hidden sm:inline text-[11px] uppercase tracking-[0.16em] text-gray-400">Assignee</span>
-                <span
-                  class="avatar-ring"
-                  :class="ticket.assignee ? 'bg-indigo-100 text-indigo-700' : 'bg-gray-200 text-gray-500'"
-                >
-                  {{ ticket.assignee ? initials(ticket.assignee.name || ticket.assignee.email) : '—' }}
-                </span>
-              </div>
-            </div>
-          </button>
-        </div>
-
-        <div v-if="tickets.last_page > 1" class="flex items-center justify-between border-t border-gray-200 px-5 py-3 text-sm">
-          <span class="text-gray-500">Page {{ tickets.current_page }} of {{ tickets.last_page }}</span>
-          <div class="flex items-center gap-2">
-            <Link
-              v-if="tickets.prev_page_url"
-              :href="tickets.prev_page_url"
-              class="rounded-xl border border-gray-200 px-3 py-1.5 text-gray-600 transition hover:bg-gray-100:bg-gray-800"
-            >Prev</Link>
-            <Link
-              v-if="tickets.next_page_url"
-              :href="tickets.next_page_url"
-              class="rounded-xl border border-gray-200 px-3 py-1.5 text-gray-600 transition hover:bg-gray-100:bg-gray-800"
-            >Next</Link>
-          </div>
-        </div>
-      </div>
-    </main>
-
-    <section
-      class="min-w-0 w-full flex-1 flex-col bg-gray-50"
-      :class="showDetail ? 'flex' : 'hidden lg:flex'"
-    >
-      <div v-if="!ticketDetail" class="flex h-full items-center justify-center p-8">
-        <div class="max-w-md rounded-3xl border border-dashed border-gray-300 bg-white p-10 text-center shadow-sm">
-          <p class="text-xs font-semibold uppercase tracking-[0.2em] text-gray-400">Conversation</p>
-          <h3 class="mt-3 text-2xl font-semibold tracking-tight">Pick a ticket</h3>
-          <p class="mt-3 text-sm leading-6 text-gray-500">
-            The right panel becomes the full thread view: metadata, internal notes, and reply composer included. Miracles do happen.
-          </p>
-        </div>
-      </div>
-
-      <template v-else>
-        <div class="border-b border-gray-200 bg-white px-4 py-5 sm:px-6">
-          <div class="mb-4 lg:hidden">
-            <button
-              type="button"
-              class="inline-flex items-center rounded-xl border border-gray-200 px-3 py-2 text-sm font-medium text-gray-600 transition hover:bg-gray-100"
-              @click="backToList"
-            >
-              ← Back to list
-            </button>
-          </div>
-
-          <div class="flex flex-wrap items-start justify-between gap-4">
-            <div class="min-w-0 flex-1">
-              <div class="flex flex-wrap items-center gap-2">
-                <span class="inline-flex rounded-full px-2.5 py-1 text-xs font-semibold text-white" :style="{ backgroundColor: ticketDetail.group?.color || '#6366f1' }">{{ ticketDetail.number }}</span>
-                <span :class="badgeClass(ticketDetail.status)" class="inline-flex rounded-full px-2.5 py-1 text-xs font-semibold">{{ statusLabel(ticketDetail.status) }}</span>
-                <span v-if="ticketDetail.priority" class="inline-flex items-center gap-2 rounded-full border border-gray-200 px-2.5 py-1 text-xs font-medium text-gray-600">
-                  <span class="h-2.5 w-2.5 rounded-full" :style="{ backgroundColor: ticketDetail.priority.color || '#94a3b8' }"></span>
-                  {{ ticketDetail.priority.name }}
-                </span>
-              </div>
-
-              <div class="mt-3 flex flex-wrap items-start gap-3">
-                <h3 class="min-w-0 flex-1 text-xl font-semibold tracking-tight text-gray-900 sm:text-2xl">{{ ticketDetail.title }}</h3>
-                <Link :href="route('ticketing.show', { ticket: ticketDetail.id })" class="shrink-0 text-sm font-medium text-indigo-600 transition hover:text-indigo-500">Open full page</Link>
-              </div>
-            </div>
-          </div>
-
-          <div class="mt-5 grid gap-3 md:grid-cols-5">
-            <div class="rounded-2xl border border-gray-200 bg-gray-50 px-4 py-3">
-              <div class="text-[11px] font-semibold uppercase tracking-[0.16em] text-gray-400">Assignee</div>
-              <div class="mt-2 flex items-center gap-2 text-sm font-medium">
-                <span class="avatar-ring bg-indigo-100 text-indigo-700">{{ ticketDetail.assignee ? initials(ticketDetail.assignee.name || ticketDetail.assignee.email) : '—' }}</span>
-                <span class="truncate">{{ ticketDetail.assignee?.name || ticketDetail.assignee?.email || 'Unassigned' }}</span>
-              </div>
-            </div>
-
-            <div class="rounded-2xl border border-gray-200 bg-gray-50 px-4 py-3">
-              <div class="text-[11px] font-semibold uppercase tracking-[0.16em] text-gray-400">Due date</div>
-              <div class="mt-2 text-sm font-medium">{{ formatDate(ticketDetail.due_date, 'No due date') }}</div>
-            </div>
-
-            <div class="rounded-2xl border border-gray-200 bg-gray-50 px-4 py-3">
-              <div class="text-[11px] font-semibold uppercase tracking-[0.16em] text-gray-400">Project</div>
-              <div class="mt-2 truncate text-sm font-medium">{{ ticketDetail.project?.name || 'No project' }}</div>
-            </div>
-
-            <div class="rounded-2xl border border-gray-200 bg-gray-50 px-4 py-3">
-              <div class="text-[11px] font-semibold uppercase tracking-[0.16em] text-gray-400">Submitter</div>
-              <div class="mt-2 truncate text-sm font-medium">{{ ticketDetail.submitter?.name || ticketDetail.submitter?.email || 'Unknown' }}</div>
-            </div>
-
-            <div class="rounded-2xl border border-gray-200 bg-gray-50 px-4 py-3">
-              <div class="text-[11px] font-semibold uppercase tracking-[0.16em] text-gray-400">Opened</div>
-              <div class="mt-2 text-sm font-medium">{{ ageLabel(ticketDetail.created_at) }}</div>
-            </div>
-          </div>
-
-          <div class="mt-4 flex flex-wrap items-center gap-x-3 gap-y-1 text-sm text-gray-500">
-            <span class="truncate">Group: <strong class="text-gray-700">{{ ticketDetail.group?.name || 'Unknown' }}</strong></span>
-            <span aria-hidden="true" class="hidden sm:inline">•</span>
-            <span>{{ ticketDetail.messages?.length || 0 }} messages</span>
-            <span aria-hidden="true">•</span>
-            <span>{{ ticketDetail.attachments?.length || 0 }} attachments</span>
-          </div>
-
-          <div v-if="isAgent" class="mt-5 grid gap-3 lg:grid-cols-4">
-            <select v-model="metaForm.status" class="meta-select" @change="saveMeta">
-              <option v-for="status in statuses" :key="status.value" :value="status.value">{{ status.label }}</option>
-            </select>
-
-            <select v-model="metaForm.priority_id" class="meta-select" @change="saveMeta">
-              <option :value="null">No priority</option>
-              <option v-for="priority in priorities" :key="priority.id" :value="priority.id">{{ priority.name }}</option>
-            </select>
-
-            <select v-model="metaForm.assigned_to" class="meta-select" @change="saveMeta">
-              <option :value="null">Unassigned</option>
-              <option v-for="agent in detailAgents" :key="agent.id" :value="agent.id">{{ agent.name || agent.email }}</option>
-            </select>
-
-            <input v-model="metaForm.due_date" type="date" class="meta-select" @change="saveMeta" />
-          </div>
-        </div>
-
-        <div class="min-h-0 flex-1 overflow-y-auto px-4 py-6 sm:px-6">
-          <div v-if="ticketDetail.description" class="mb-6 rounded-3xl border border-gray-200 bg-white p-5 shadow-sm">
-            <div class="mb-2 text-[11px] font-semibold uppercase tracking-[0.16em] text-gray-400">Description</div>
-            <p class="whitespace-pre-wrap text-sm leading-6 text-gray-700">{{ ticketDetail.description }}</p>
-          </div>
-
-          <div v-if="!ticketDetail.messages?.length" class="rounded-3xl border border-dashed border-gray-300 bg-white p-8 text-center text-sm text-gray-500">
-            No messages yet.
-          </div>
-
-          <div v-else class="space-y-4">
-            <div
-              v-for="message in ticketDetail.messages"
-              :key="message.id"
-              class="flex"
-              :class="messageAlignment(message)"
-            >
-              <div class="max-w-3xl rounded-3xl px-5 py-4 shadow-sm" :class="messageCardClass(message)">
-                <div class="flex flex-wrap items-center gap-2 text-xs font-medium opacity-80">
-                  <span class="inline-flex items-center gap-2">
-                    <span class="avatar-ring bg-white/70 text-gray-700">{{ initials(messageAuthor(message)) }}</span>
-                    {{ messageRoleLabel(message) }}
-                  </span>
-                  <span>•</span>
-                  <span>{{ message.author?.name || message.author_email || 'Unknown' }}</span>
-                  <span>•</span>
-                  <span>{{ preciseDate(message.created_at) }}</span>
-                </div>
-
-                <p class="mt-3 whitespace-pre-wrap text-sm leading-6">{{ message.body }}</p>
-
-                <div v-if="message.attachments?.length" class="mt-4 flex flex-wrap gap-2">
-                  <a
-                    v-for="attachment in message.attachments"
-                    :key="attachment.id"
-                    :href="route('ticketing.attachments.show', { attachment: attachment.id })"
-                    class="inline-flex items-center gap-2 rounded-full border border-current/20 px-3 py-1.5 text-xs font-medium transition hover:bg-white/30:bg-gray-900/30"
-                    target="_blank"
-                  >
-                    📎 {{ attachment.filename }}
-                  </a>
-                </div>
-              </div>
-            </div>
-          </div>
-        </div>
-
-        <div class="border-t border-gray-200 bg-white px-4 py-5 sm:px-6">
-          <div v-if="isAgent" class="mb-4 inline-flex rounded-2xl bg-gray-100 p-1">
-            <button
-              type="button"
-              class="rounded-2xl px-4 py-2 text-sm font-medium transition"
-              :class="replyMode === 'reply' ? 'bg-white text-gray-900 shadow-sm' : 'text-gray-500'"
-              @click="replyMode = 'reply'"
-            >Reply</button>
-            <button
-              type="button"
-              class="rounded-2xl px-4 py-2 text-sm font-medium transition"
-              :class="replyMode === 'internal' ? 'bg-amber-500 text-white shadow-sm' : 'text-gray-500'"
-              @click="replyMode = 'internal'"
-            >Internal note</button>
-          </div>
-
-          <form @submit.prevent="sendMessage" class="space-y-3">
-            <textarea
-              v-model="messageForm.body"
-              rows="4"
-              required
-              class="w-full rounded-3xl border px-4 py-3 text-sm outline-none transition focus:ring-2"
-              :class="replyMode === 'internal'
-                ? 'border-amber-300 bg-amber-50 text-amber-950 focus:border-amber-400 focus:ring-amber-100:ring-amber-500/20'
-                : 'border-gray-200 bg-gray-50 text-gray-900 focus:border-indigo-400 focus:ring-indigo-100:border-indigo-500:ring-indigo-500/20'"
-              :placeholder="replyMode === 'internal' ? 'Internal note for agents only…' : 'Reply to the thread…'"
-            ></textarea>
-
-            <div class="flex flex-wrap items-center justify-between gap-3">
-              <div class="text-xs text-gray-400">
-                {{ replyMode === 'internal' ? 'Only agents can see internal notes.' : 'Replies are visible in the ticket thread.' }}
-              </div>
-              <button
-                type="submit"
-                :disabled="messageForm.processing"
-                class="inline-flex items-center rounded-2xl px-4 py-2 text-sm font-medium text-white transition disabled:cursor-not-allowed disabled:opacity-60"
-                :class="replyMode === 'internal' ? 'bg-amber-500 hover:bg-amber-600' : 'bg-gray-900 hover:bg-gray-700:bg-indigo-400'"
-              >
-                {{ messageForm.processing ? 'Sending…' : replyMode === 'internal' ? 'Save note' : 'Send reply' }}
-              </button>
-            </div>
-          </form>
-        </div>
-      </template>
-    </section>
-  </template>
-  </div>
-</template>
-
-<script setup>
-import { computed, ref, watch } from 'vue'
-import { Link, router, useForm } from '@inertiajs/vue3'
-
-const props = defineProps({
-  tickets: Object,
-  groups: Array,
-  priorities: Array,
-  projects: Array,
-  isAgent: Boolean,
-  filters: Object,
-  ticketDetail: Object,
-  detailAgents: Array,
-  viewCounts: Object,
-  isBootstrap: Boolean,
-})
-
-const search = ref('')
-const sortBy = ref('newest')
-const activeGroupId = ref(props.filters?.group_id ? Number(props.filters.group_id) : null)
-const replyMode = ref('reply')
-const showSidebar = ref(!props.ticketDetail)
-
-const visibleViews = computed(() => {
-  const base = [
-    { key: 'all', label: 'All Open' },
-    { key: 'mine', label: 'Mine' },
-    { key: 'unassigned', label: 'Unassigned' },
-    { key: 'pending', label: 'Pending' },
-    { key: 'resolved', label: 'Resolved' },
-  ]
-
-  return props.isAgent ? base : base.filter((view) => ['all', 'pending', 'resolved'].includes(view.key))
-})
-
-const currentFilter = computed(() => props.filters?.filter || 'all')
-const selectedTicketId = computed(() => props.ticketDetail?.id ?? (props.filters?.detail ? Number(props.filters.detail) : null))
-const currentViewTitle = computed(() => visibleViews.value.find((view) => view.key === currentFilter.value)?.label || 'Tickets')
-const totalProjectCount = computed(() => props.projects.reduce((sum, project) => sum + Number(project.ticket_count || 0), 0))
-const showList = computed(() => !props.ticketDetail)
-const showDetail = computed(() => !!props.ticketDetail)
-
-const filteredTickets = computed(() => {
-  const term = search.value.trim().toLowerCase()
-  const priorityWeight = Object.fromEntries(
-    [...props.priorities].sort((a, b) => (a.sort_order ?? 0) - (b.sort_order ?? 0)).map((priority, index, arr) => [priority.id, arr.length - index])
-  )
-
-  let items = [...(props.tickets?.data || [])]
-
-  if (term) {
-    items = items.filter((ticket) => {
-      const haystack = [
-        ticket.number,
-        ticket.title,
-        ticket.status,
-        ticket.submitter?.name,
-        ticket.submitter?.email,
-        ticket.assignee?.name,
-        ticket.assignee?.email,
-        ticket.priority?.name,
-      ].filter(Boolean).join(' ').toLowerCase()
-
-      return haystack.includes(term)
-    })
-  }
-
-  items.sort((a, b) => {
-    if (sortBy.value === 'oldest') {
-      return new Date(a.created_at) - new Date(b.created_at)
-    }
-
-    if (sortBy.value === 'priority') {
-      return (priorityWeight[b.priority_id] || 0) - (priorityWeight[a.priority_id] || 0) || new Date(b.created_at) - new Date(a.created_at)
-    }
-
-    if (sortBy.value === 'status') {
-      return statusSortValue(a.status) - statusSortValue(b.status) || new Date(b.created_at) - new Date(a.created_at)
-    }
-
-    return new Date(b.created_at) - new Date(a.created_at)
-  })
-
-  return items
-})
-
-const metaForm = useForm({
-  status: props.ticketDetail?.status ?? 'open',
-  priority_id: props.ticketDetail?.priority_id ?? null,
-  assigned_to: props.ticketDetail?.assigned_to ?? null,
-  due_date: props.ticketDetail?.due_date ?? null,
-})
-
-const messageForm = useForm({
-  body: '',
-  is_internal: false,
-})
-
-watch(
-  () => props.ticketDetail,
-  (detail) => {
-    replyMode.value = 'reply'
-    showSidebar.value = !detail
-    metaForm.defaults({
-      status: detail?.status ?? 'open',
-      priority_id: detail?.priority_id ?? null,
-      assigned_to: detail?.assigned_to ?? null,
-      due_date: detail?.due_date ?? null,
-    })
-    metaForm.reset()
-  },
-  { immediate: true }
-)
-
-const statuses = [
-  { value: 'open', label: 'Open' },
-  { value: 'in_progress', label: 'In Progress' },
-  { value: 'pending', label: 'Pending' },
-  { value: 'resolved', label: 'Resolved' },
-  { value: 'closed', label: 'Closed' },
-]
-
-function normalizeNullable(value) {
-  return value === '' || value === null || value === undefined ? undefined : Number(value)
-}
-
-function buildParams(overrides = {}) {
-  const params = {
-    ...props.filters,
-    ...overrides,
-  }
-
-  Object.keys(params).forEach((key) => {
-    if (params[key] === undefined || params[key] === null || params[key] === '') {
-      delete params[key]
-    }
-  })
-
-  return params
-}
-
-function applyFilters(overrides = {}) {
-  const params = buildParams({ ...overrides, detail: overrides.detail === undefined ? props.filters?.detail : overrides.detail })
-
-  router.get(route('ticketing.index'), params, {
-    preserveState: true,
-    preserveScroll: true,
-    replace: true,
-  })
-}
-
-function togglePriority(priorityId) {
-  applyFilters({ priority_id: Number(props.filters.priority_id) === priorityId ? undefined : priorityId })
-}
-
-function selectTicket(ticketId) {
-  router.get(route('ticketing.index'), buildParams({ detail: ticketId }), {
-    preserveState: true,
-    preserveScroll: true,
-    replace: true,
-    only: ['ticketDetail', 'detailAgents', 'filters'],
-  })
-}
-
-function backToList() {
-  router.get(route('ticketing.index'), buildParams({ detail: undefined }), {
-    preserveState: true,
-    preserveScroll: true,
-    replace: true,
-    only: ['ticketDetail', 'detailAgents', 'filters'],
-  })
-}
-
-function saveMeta() {
-  if (!props.ticketDetail) return
-
-  metaForm.transform((data) => ({
-    ...data,
-    priority_id: normalizeNullable(data.priority_id),
-    assigned_to: normalizeNullable(data.assigned_to),
-    due_date: data.due_date || null,
-  })).put(route('ticketing.update', { ticket: props.ticketDetail.id }), {
-    preserveScroll: true,
-    onSuccess: () => {
-      router.reload({ only: ['tickets', 'ticketDetail', 'detailAgents'] })
-    },
-  })
-}
-
-function sendMessage() {
-  if (!props.ticketDetail) return
-
-  messageForm.transform((data) => ({
-    ...data,
-    is_internal: props.isAgent && replyMode.value === 'internal',
-  })).post(route('ticketing.messages.store', { ticket: props.ticketDetail.id }), {
-    preserveScroll: true,
-    onSuccess: () => {
-      messageForm.reset()
-      router.reload({ only: ['tickets', 'ticketDetail', 'detailAgents'] })
-    },
-  })
-}
-
-function viewCount(key) {
-  return props.viewCounts?.[key] ?? 0
-}
-
-function initials(value) {
-  return String(value || '?')
-    .split(/\s+/)
-    .filter(Boolean)
-    .slice(0, 2)
-    .map((part) => part[0])
-    .join('')
-    .toUpperCase()
-}
-
-function badgeClass(status) {
-  return {
-    open: 'bg-sky-100 text-sky-700',
-    in_progress: 'bg-violet-100 text-violet-700',
-    pending: 'bg-amber-100 text-amber-700',
-    resolved: 'bg-emerald-100 text-emerald-700',
-    closed: 'bg-gray-200 text-gray-700',
-  }[status] || 'bg-gray-200 text-gray-700'
-}
-
-function priorityChipStyle(priority, active) {
-  const color = priority.color || '#94a3b8'
-  return active
-    ? { borderColor: color, backgroundColor: `${color}18`, color }
-    : {}
-}
-
-function statusLabel(status) {
-  return {
-    open: 'Open',
-    in_progress: 'In Progress',
-    pending: 'Pending',
-    resolved: 'Resolved',
-    closed: 'Closed',
-  }[status] || status
-}
-
-function statusSortValue(status) {
-  return {
-    open: 1,
-    in_progress: 2,
-    pending: 3,
-    resolved: 4,
-    closed: 5,
-  }[status] || 99
-}
-
-function ageLabel(value) {
-  return relativeTime(value)
-}
-
-function preciseDate(value) {
-  if (!value) return 'Unknown time'
-  return new Date(value).toLocaleString()
-}
-
-function formatDate(value, fallback = '—') {
-  if (!value) return fallback
-  return new Date(value).toLocaleDateString(undefined, { year: 'numeric', month: 'short', day: 'numeric' })
-}
-
-function relativeTime(value) {
-  if (!value) return '—'
-  const date = new Date(value)
-  const diff = Math.max(1, Math.floor((Date.now() - date.getTime()) / 1000))
-  if (diff < 60) return `${diff}s ago`
-  if (diff < 3600) return `${Math.floor(diff / 60)}m ago`
-  if (diff < 86400) return `${Math.floor(diff / 3600)}h ago`
-  if (diff < 604800) return `${Math.floor(diff / 86400)}d ago`
-  return `${Math.floor(diff / 604800)}w ago`
-}
-
-function hasUnread(ticket) {
-  if (!ticket || !props.ticketDetail) return false
-  return ticket.id !== props.ticketDetail.id && ['open', 'pending'].includes(ticket.status)
-}
-
-function messageAlignment(message) {
-  if (message.is_internal) return 'justify-center'
-  return isSubmitterMessage(message) ? 'justify-start' : 'justify-end'
-}
-
-function messageCardClass(message) {
-  if (message.is_internal) {
-    return 'border border-amber-200 bg-amber-50 text-amber-950'
-  }
-
-  if (isSubmitterMessage(message)) {
-    return 'border border-gray-200 bg-white text-gray-800'
-  }
-
-  return 'bg-gray-900 text-white'
-}
-
-function isSubmitterMessage(message) {
-  return Number(message.user_id) === Number(props.ticketDetail?.submitter_id)
-}
-
-function messageRoleLabel(message) {
-  if (message.is_internal) return 'Internal note'
-  return isSubmitterMessage(message) ? 'Submitter' : 'Agent reply'
-}
-
-function messageAuthor(message) {
-  return message.author?.name || message.author?.email || message.author_email || 'Unknown'
-}
-</script>
-
-<style scoped>
-.avatar-ring {
-  @apply inline-flex h-8 w-8 items-center justify-center rounded-full text-[11px] font-semibold;
-}
-
-.meta-select {
-  @apply w-full rounded-2xl border border-gray-200 bg-gray-50 px-4 py-3 text-sm outline-none transition focus:border-indigo-400 focus:ring-2 focus:ring-indigo-100 focus:ring-indigo-500/20;
-}
-</style>

resources/js/Pages/Ticketing/MyTickets.vue

@@ -1,76 +0,0 @@
-<template>
-  <AppLayout>
-    <div class="max-w-3xl mx-auto">
-      <div class="mb-6 flex justify-between items-center">
-        <h1 class="text-2xl font-bold text-gray-900">My Tickets</h1>
-        <Link :href="route('ticketing.create')" class="inline-flex items-center gap-1 bg-gray-900 text-white text-sm px-4 py-2 rounded-lg hover:bg-gray-700 transition">
-          + Submit Ticket
-        </Link>
-      </div>
-
-      <div class="bg-white rounded-xl shadow-sm border border-gray-200 divide-y divide-gray-100">
-        <div v-if="tickets.data.length === 0" class="p-8 text-center text-gray-400 text-sm">
-          You haven't submitted any tickets yet.
-        </div>
-        <Link
-          v-for="ticket in tickets.data"
-          :key="ticket.id"
-          :href="route('ticketing.show', { ticket: ticket.id })"
-          class="flex items-start gap-3 px-4 py-3 hover:bg-gray-50 transition"
-        >
-          <span
-            class="inline-block text-xs font-mono font-semibold px-2 py-1 rounded text-white flex-shrink-0 mt-0.5"
-            :style="{ backgroundColor: ticket.group?.color || '#6366f1' }"
-          >{{ ticket.number }}</span>
-          <div class="flex-1 min-w-0">
-            <p class="text-sm font-medium text-gray-800 truncate">{{ ticket.title }}</p>
-            <p class="text-xs text-gray-400 mt-0.5">{{ ticket.group?.name }} · {{ timeAgo(ticket.created_at) }}</p>
-          </div>
-          <span :class="statusClass(ticket.status)" class="text-xs px-2 py-0.5 rounded-full font-medium flex-shrink-0">
-            {{ statusLabel(ticket.status) }}
-          </span>
-        </Link>
-      </div>
-
-      <!-- Pagination -->
-      <div v-if="tickets.last_page > 1" class="mt-4 flex justify-center gap-4 text-sm">
-        <Link v-if="tickets.prev_page_url" :href="tickets.prev_page_url" class="text-indigo-600 hover:underline">← Previous</Link>
-        <span class="text-gray-500">{{ tickets.current_page }} / {{ tickets.last_page }}</span>
-        <Link v-if="tickets.next_page_url" :href="tickets.next_page_url" class="text-indigo-600 hover:underline">Next →</Link>
-      </div>
-    </div>
-  </AppLayout>
-</template>
-
-<script setup>
-import AppLayout from '@/Layouts/AppLayout.vue'
-import { Link } from '@inertiajs/vue3'
-
-defineProps({ tickets: Object })
-
-function statusLabel(status) {
-  const map = { open: 'Open', in_progress: 'In Progress', pending: 'Pending', resolved: 'Resolved', closed: 'Closed' }
-  return map[status] || status
-}
-
-function statusClass(status) {
-  const map = {
-    open: 'bg-blue-100 text-blue-700',
-    in_progress: 'bg-purple-100 text-purple-700',
-    pending: 'bg-yellow-100 text-yellow-700',
-    resolved: 'bg-green-100 text-green-700',
-    closed: 'bg-gray-100 text-gray-500',
-  }
-  return map[status] || 'bg-gray-100 text-gray-600'
-}
-
-function timeAgo(dateStr) {
-  const date = new Date(dateStr)
-  const now = new Date()
-  const diff = Math.floor((now - date) / 1000)
-  if (diff < 60) return `${diff}s ago`
-  if (diff < 3600) return `${Math.floor(diff / 60)}m ago`
-  if (diff < 86400) return `${Math.floor(diff / 3600)}h ago`
-  return `${Math.floor(diff / 86400)}d ago`
-}
-</script>

resources/js/Pages/Ticketing/Settings.vue

@@ -1,560 +0,0 @@
-<template>
-  <div class="max-w-5xl mx-auto py-8 px-4">
-    <div class="mb-6">
-      <Link :href="route('ticketing.index')" class="text-sm text-indigo-600 hover:underline">← Back to tickets</Link>
-      <h1 class="text-xl font-bold text-gray-900 mt-2 sm:text-2xl">Ticketing Settings</h1>
-    </div>
-
-    <div v-if="isBootstrap" class="mb-6 px-5 py-4 bg-amber-50 border border-amber-300 rounded-xl">
-      <h2 class="text-base font-semibold text-amber-800 mb-1">🚀 First-Run Setup</h2>
-      <p class="text-sm text-amber-700">
-        No groups exist yet. Create your first group below to get started.
-        Default priorities (Low, Medium, High, Urgent) will be seeded automatically.
-      </p>
-    </div>
-
-    <div v-if="$page.props.flash?.success" class="mb-4 px-4 py-2 bg-green-50 border border-green-200 text-green-700 rounded-lg text-sm">
-      {{ $page.props.flash.success }}
-    </div>
-
-    <div v-if="$page.props.errors?.priority" class="mb-4 px-4 py-2 bg-red-50 border border-red-200 text-red-700 rounded-lg text-sm">
-      {{ $page.props.errors.priority }}
-    </div>
-
-    <div v-if="$page.props.errors?.project" class="mb-4 px-4 py-2 bg-red-50 border border-red-200 text-red-700 rounded-lg text-sm">
-      {{ $page.props.errors.project }}
-    </div>
-
-    <div class="flex gap-1 border-b border-gray-200 mb-6 overflow-x-auto scrollbar-none -mx-4 px-4 sm:mx-0 sm:px-0">
-      <button
-        v-for="tab in tabs"
-        :key="tab.key"
-        @click="activeTab = tab.key"
-        :class="[
-          'shrink-0 px-4 py-2.5 text-sm font-medium border-b-2 transition',
-          activeTab === tab.key
-            ? 'border-indigo-600 text-indigo-600'
-            : 'border-transparent text-gray-500 hover:text-gray-700'
-        ]"
-      >{{ tab.label }}</button>
-    </div>
-
-    <div v-if="activeTab === 'groups'">
-      <div class="flex flex-wrap justify-between items-center gap-2 mb-4">
-        <h2 class="text-lg font-semibold text-gray-800">Groups</h2>
-        <button @click="showAddGroup = !showAddGroup" class="text-sm text-indigo-600 hover:underline">
-          {{ showAddGroup ? 'Cancel' : '+ Add Group' }}
-        </button>
-      </div>
-
-      <div v-if="showAddGroup" class="bg-gray-50 rounded-xl p-4 mb-5 space-y-3">
-        <h3 class="text-sm font-semibold text-gray-700">New Group</h3>
-        <form @submit.prevent="submitGroup" class="grid grid-cols-1 gap-3 sm:grid-cols-2">
-          <div>
-            <label class="block text-xs text-gray-500 mb-1">Name</label>
-            <input v-model="groupForm.name" required type="text" class="w-full text-sm border-gray-300 rounded-lg" />
-          </div>
-          <div>
-            <label class="block text-xs text-gray-500 mb-1">Prefix (e.g. IT)</label>
-            <input v-model="groupForm.prefix" required type="text" maxlength="10" class="w-full text-sm border-gray-300 rounded-lg uppercase" />
-          </div>
-          <div>
-            <label class="block text-xs text-gray-500 mb-1">Email Address</label>
-            <input v-model="groupForm.email_address" type="email" class="w-full text-sm border-gray-300 rounded-lg" />
-          </div>
-          <div>
-            <label class="block text-xs text-gray-500 mb-1">Color</label>
-            <input v-model="groupForm.color" type="color" class="h-9 w-full border-gray-300 rounded-lg cursor-pointer" />
-          </div>
-          <div class="col-span-1 sm:col-span-2 flex justify-end">
-            <button type="submit" :disabled="groupForm.processing" class="bg-indigo-600 text-white text-sm px-4 py-2 rounded-lg hover:bg-indigo-700 disabled:opacity-60">
-              Create Group
-            </button>
-          </div>
-        </form>
-      </div>
-
-      <div class="space-y-3">
-        <div v-if="groups.length === 0" class="text-sm text-gray-400 italic">No groups yet.</div>
-        <div
-          v-for="group in groups"
-          :key="group.id"
-          class="flex items-center justify-between px-4 py-3 bg-white border border-gray-200 rounded-xl"
-        >
-          <div class="flex items-center gap-3">
-            <span class="w-3 h-3 rounded-full" :style="{ backgroundColor: group.color }"></span>
-            <div>
-              <p class="font-medium text-sm text-gray-800">{{ group.name }}</p>
-              <p class="text-xs text-gray-400">{{ group.prefix }} · {{ group.email_address || 'No email' }}</p>
-            </div>
-          </div>
-          <button @click="startEditGroup(group)" class="text-xs text-indigo-600 hover:underline">Edit</button>
-        </div>
-      </div>
-
-      <div v-if="editingGroup" class="mt-4 bg-gray-50 rounded-xl p-4 space-y-3">
-        <h3 class="text-sm font-semibold text-gray-700">Edit: {{ editingGroup.name }}</h3>
-        <form @submit.prevent="submitEditGroup" class="grid grid-cols-1 gap-3 sm:grid-cols-2">
-          <div>
-            <label class="block text-xs text-gray-500 mb-1">Name</label>
-            <input v-model="editGroupForm.name" required type="text" class="w-full text-sm border-gray-300 rounded-lg" />
-          </div>
-          <div>
-            <label class="block text-xs text-gray-500 mb-1">Prefix</label>
-            <input v-model="editGroupForm.prefix" required type="text" maxlength="10" class="w-full text-sm border-gray-300 rounded-lg uppercase" />
-          </div>
-          <div>
-            <label class="block text-xs text-gray-500 mb-1">Email Address</label>
-            <input v-model="editGroupForm.email_address" type="email" class="w-full text-sm border-gray-300 rounded-lg" />
-          </div>
-          <div>
-            <label class="block text-xs text-gray-500 mb-1">Color</label>
-            <input v-model="editGroupForm.color" type="color" class="h-9 w-full border-gray-300 rounded-lg cursor-pointer" />
-          </div>
-          <div class="col-span-1 sm:col-span-2 flex justify-end gap-2">
-            <button type="button" @click="editingGroup = null" class="text-sm text-gray-500 px-3 py-2 rounded-lg border border-gray-300 hover:bg-gray-100">Cancel</button>
-            <button type="submit" :disabled="editGroupForm.processing" class="bg-indigo-600 text-white text-sm px-4 py-2 rounded-lg hover:bg-indigo-700 disabled:opacity-60">Save</button>
-          </div>
-        </form>
-      </div>
-    </div>
-
-    <div v-if="activeTab === 'agents'">
-      <div class="flex flex-wrap justify-between items-center gap-2 mb-4">
-        <h2 class="text-lg font-semibold text-gray-800">Agents</h2>
-        <button @click="showAddAgent = !showAddAgent" class="text-sm text-indigo-600 hover:underline">
-          {{ showAddAgent ? 'Cancel' : '+ Add Agent' }}
-        </button>
-      </div>
-
-      <div v-if="showAddAgent" class="bg-gray-50 rounded-xl p-4 mb-5 space-y-3">
-        <form @submit.prevent="submitAgent" class="grid grid-cols-1 gap-3 sm:grid-cols-3">
-          <div>
-            <label class="block text-xs text-gray-500 mb-1">User ID</label>
-            <input v-model="agentForm.user_id" required type="number" placeholder="User ID" class="w-full text-sm border-gray-300 rounded-lg" />
-          </div>
-          <div>
-            <label class="block text-xs text-gray-500 mb-1">Group</label>
-            <select v-model="agentForm.group_id" required class="w-full text-sm border-gray-300 rounded-lg">
-              <option value="">Select group</option>
-              <option v-for="g in groups" :key="g.id" :value="g.id">{{ g.name }}</option>
-            </select>
-          </div>
-          <div>
-            <label class="block text-xs text-gray-500 mb-1">Role</label>
-            <select v-model="agentForm.role" class="w-full text-sm border-gray-300 rounded-lg">
-              <option value="agent">Agent</option>
-              <option value="manager">Manager</option>
-            </select>
-          </div>
-          <div class="col-span-1 sm:col-span-3 flex justify-end">
-            <button type="submit" :disabled="agentForm.processing" class="bg-indigo-600 text-white text-sm px-4 py-2 rounded-lg hover:bg-indigo-700 disabled:opacity-60">
-              Add Agent
-            </button>
-          </div>
-        </form>
-      </div>
-
-      <div class="space-y-2">
-        <div v-if="agents.length === 0" class="text-sm text-gray-400 italic">No agents configured yet.</div>
-        <div
-          v-for="access in agents"
-          :key="access.id"
-          class="flex items-center justify-between px-4 py-2.5 bg-white border border-gray-200 rounded-xl"
-        >
-          <div>
-            <p class="text-sm font-medium text-gray-800">{{ access.user?.name || 'User #' + access.user_id }}</p>
-            <p class="text-xs text-gray-400">{{ access.user?.email }} · {{ access.group?.name || 'Unknown Group' }} · <span class="capitalize">{{ access.role }}</span></p>
-          </div>
-          <button @click="openRemoveAgentModal(access)" class="text-xs text-red-500 hover:underline">Remove</button>
-        </div>
-      </div>
-    </div>
-
-    <div v-if="activeTab === 'priorities'">
-      <div class="flex flex-wrap justify-between items-center gap-2 mb-4">
-        <h2 class="text-lg font-semibold text-gray-800">Priority Levels</h2>
-        <button @click="showAddPriority = !showAddPriority" class="text-sm text-indigo-600 hover:underline">
-          {{ showAddPriority ? 'Cancel' : '+ Add Priority' }}
-        </button>
-      </div>
-
-      <div v-if="showAddPriority" class="bg-gray-50 rounded-xl p-4 mb-5 space-y-3">
-        <form @submit.prevent="submitPriority" class="grid grid-cols-1 gap-3 sm:grid-cols-2">
-          <div>
-            <label class="block text-xs text-gray-500 mb-1">Name</label>
-            <input v-model="priorityForm.name" required type="text" class="w-full text-sm border-gray-300 rounded-lg" />
-          </div>
-          <div>
-            <label class="block text-xs text-gray-500 mb-1">Color</label>
-            <input v-model="priorityForm.color" type="color" class="h-9 w-full border-gray-300 rounded-lg cursor-pointer" />
-          </div>
-          <div class="col-span-1 sm:col-span-2">
-            <label class="block text-xs text-gray-500 mb-1">Description</label>
-            <input v-model="priorityForm.description" type="text" class="w-full text-sm border-gray-300 rounded-lg" />
-          </div>
-          <div>
-            <label class="block text-xs text-gray-500 mb-1">Sort Order</label>
-            <input v-model="priorityForm.sort_order" type="number" min="0" class="w-full text-sm border-gray-300 rounded-lg" />
-          </div>
-          <div>
-            <label class="block text-xs text-gray-500 mb-1">Group (blank = global)</label>
-            <select v-model="priorityForm.group_id" class="w-full text-sm border-gray-300 rounded-lg">
-              <option :value="null">Global</option>
-              <option v-for="g in groups" :key="g.id" :value="g.id">{{ g.name }}</option>
-            </select>
-          </div>
-          <div class="col-span-1 sm:col-span-2 flex justify-end">
-            <button type="submit" :disabled="priorityForm.processing" class="bg-indigo-600 text-white text-sm px-4 py-2 rounded-lg hover:bg-indigo-700 disabled:opacity-60">
-              Create Priority
-            </button>
-          </div>
-        </form>
-      </div>
-
-      <div class="space-y-2">
-        <div v-if="priorities.length === 0" class="text-sm text-gray-400 italic">No priorities defined yet.</div>
-        <div
-          v-for="p in priorities"
-          :key="p.id"
-          class="flex items-center gap-3 px-4 py-2.5 bg-white border border-gray-200 rounded-xl"
-        >
-          <span class="w-3 h-3 rounded-full flex-shrink-0" :style="{ backgroundColor: p.color }"></span>
-          <div class="flex-1">
-            <p class="text-sm font-medium text-gray-800">{{ p.name }}</p>
-            <p v-if="p.description" class="text-xs text-gray-400">{{ p.description }}</p>
-          </div>
-          <span class="text-xs text-gray-400">{{ p.group_id ? 'Group-specific' : 'Global' }}</span>
-          <div class="flex items-center gap-3">
-            <button @click="startEditPriority(p)" class="text-xs text-indigo-600 hover:underline">Edit</button>
-            <button @click="openDeletePriorityModal(p)" class="text-xs text-red-500 hover:underline">Delete</button>
-          </div>
-        </div>
-      </div>
-
-      <div v-if="editingPriority" class="mt-4 bg-gray-50 rounded-xl p-4 space-y-3">
-        <h3 class="text-sm font-semibold text-gray-700">Edit Priority: {{ editingPriority.name }}</h3>
-        <form @submit.prevent="submitEditPriority" class="grid grid-cols-1 gap-3 sm:grid-cols-2">
-          <div>
-            <label class="block text-xs text-gray-500 mb-1">Name</label>
-            <input v-model="editPriorityForm.name" required type="text" class="w-full text-sm border-gray-300 rounded-lg" />
-          </div>
-          <div>
-            <label class="block text-xs text-gray-500 mb-1">Color</label>
-            <input v-model="editPriorityForm.color" type="color" class="h-9 w-full border-gray-300 rounded-lg cursor-pointer" />
-          </div>
-          <div class="col-span-1 sm:col-span-2">
-            <label class="block text-xs text-gray-500 mb-1">Description</label>
-            <input v-model="editPriorityForm.description" type="text" class="w-full text-sm border-gray-300 rounded-lg" />
-          </div>
-          <div>
-            <label class="block text-xs text-gray-500 mb-1">Sort Order</label>
-            <input v-model="editPriorityForm.sort_order" type="number" min="0" class="w-full text-sm border-gray-300 rounded-lg" />
-          </div>
-          <div>
-            <label class="block text-xs text-gray-500 mb-1">Scope</label>
-            <input :value="editingPriority.group_id ? 'Group-specific' : 'Global'" disabled type="text" class="w-full text-sm border-gray-300 rounded-lg opacity-70" />
-          </div>
-          <div class="col-span-1 sm:col-span-2 flex justify-end gap-2">
-            <button type="button" @click="editingPriority = null" class="text-sm text-gray-500 px-3 py-2 rounded-lg border border-gray-300 hover:bg-gray-100">Cancel</button>
-            <button type="submit" :disabled="editPriorityForm.processing" class="bg-indigo-600 text-white text-sm px-4 py-2 rounded-lg hover:bg-indigo-700 disabled:opacity-60">Save</button>
-          </div>
-        </form>
-      </div>
-    </div>
-
-    <div v-if="activeTab === 'projects'">
-      <div class="flex flex-wrap justify-between items-center gap-2 mb-4">
-        <h2 class="text-lg font-semibold text-gray-800">Projects</h2>
-        <button @click="showAddProject = !showAddProject" class="text-sm text-indigo-600 hover:underline">
-          {{ showAddProject ? 'Cancel' : '+ Add Project' }}
-        </button>
-      </div>
-
-      <div v-if="showAddProject" class="bg-gray-50 rounded-xl p-4 mb-5 space-y-3">
-        <form @submit.prevent="submitProject" class="grid grid-cols-1 gap-3 sm:grid-cols-2">
-          <div>
-            <label class="block text-xs text-gray-500 mb-1">Group</label>
-            <select v-model="projectForm.group_id" required class="w-full text-sm border-gray-300 rounded-lg">
-              <option value="">Select group</option>
-              <option v-for="g in groups" :key="g.id" :value="g.id">{{ g.name }}</option>
-            </select>
-          </div>
-          <div>
-            <label class="block text-xs text-gray-500 mb-1">Status</label>
-            <select v-model="projectForm.status" class="w-full text-sm border-gray-300 rounded-lg">
-              <option value="active">Active</option>
-              <option value="archived">Archived</option>
-            </select>
-          </div>
-          <div class="col-span-1 sm:col-span-2">
-            <label class="block text-xs text-gray-500 mb-1">Name</label>
-            <input v-model="projectForm.name" required type="text" class="w-full text-sm border-gray-300 rounded-lg" />
-          </div>
-          <div class="col-span-1 sm:col-span-2">
-            <label class="block text-xs text-gray-500 mb-1">Description</label>
-            <textarea v-model="projectForm.description" rows="3" class="w-full text-sm border-gray-300 rounded-lg"></textarea>
-          </div>
-          <div class="col-span-1 sm:col-span-2 flex justify-end">
-            <button type="submit" :disabled="projectForm.processing" class="bg-indigo-600 text-white text-sm px-4 py-2 rounded-lg hover:bg-indigo-700 disabled:opacity-60">
-              Create Project
-            </button>
-          </div>
-        </form>
-      </div>
-
-      <div class="space-y-2">
-        <div v-if="projects.length === 0" class="text-sm text-gray-400 italic">No projects defined yet.</div>
-        <div
-          v-for="project in projects"
-          :key="project.id"
-          class="flex items-center gap-3 px-4 py-3 bg-white border border-gray-200 rounded-xl"
-        >
-          <div class="flex-1">
-            <p class="text-sm font-medium text-gray-800">{{ project.name }}</p>
-            <p class="text-xs text-gray-400">{{ groups.find(g => g.id === project.group_id)?.name || 'Unknown Group' }} · {{ project.status }}</p>
-            <p v-if="project.description" class="text-xs text-gray-500 mt-1">{{ project.description }}</p>
-          </div>
-          <div class="flex items-center gap-3">
-            <button @click="startEditProject(project)" class="text-xs text-indigo-600 hover:underline">Edit</button>
-            <button @click="openDeleteProjectModal(project)" class="text-xs text-red-500 hover:underline">Delete</button>
-          </div>
-        </div>
-      </div>
-
-      <div v-if="editingProject" class="mt-4 bg-gray-50 rounded-xl p-4 space-y-3">
-        <h3 class="text-sm font-semibold text-gray-700">Edit Project: {{ editingProject.name }}</h3>
-        <form @submit.prevent="submitEditProject" class="grid grid-cols-1 gap-3 sm:grid-cols-2">
-          <div class="col-span-1 sm:col-span-2">
-            <label class="block text-xs text-gray-500 mb-1">Name</label>
-            <input v-model="editProjectForm.name" required type="text" class="w-full text-sm border-gray-300 rounded-lg" />
-          </div>
-          <div>
-            <label class="block text-xs text-gray-500 mb-1">Status</label>
-            <select v-model="editProjectForm.status" class="w-full text-sm border-gray-300 rounded-lg">
-              <option value="active">Active</option>
-              <option value="archived">Archived</option>
-            </select>
-          </div>
-          <div>
-            <label class="block text-xs text-gray-500 mb-1">Group</label>
-            <input :value="groups.find(g => g.id === editingProject.group_id)?.name || 'Unknown Group'" disabled type="text" class="w-full text-sm border-gray-300 rounded-lg opacity-70" />
-          </div>
-          <div class="col-span-1 sm:col-span-2">
-            <label class="block text-xs text-gray-500 mb-1">Description</label>
-            <textarea v-model="editProjectForm.description" rows="3" class="w-full text-sm border-gray-300 rounded-lg"></textarea>
-          </div>
-          <div class="col-span-1 sm:col-span-2 flex justify-end gap-2">
-            <button type="button" @click="editingProject = null" class="text-sm text-gray-500 px-3 py-2 rounded-lg border border-gray-300 hover:bg-gray-100">Cancel</button>
-            <button type="submit" :disabled="editProjectForm.processing" class="bg-indigo-600 text-white text-sm px-4 py-2 rounded-lg hover:bg-indigo-700 disabled:opacity-60">Save</button>
-          </div>
-        </form>
-      </div>
-    </div>
-  </div>
-
-  <div v-if="removeAgentModalOpen" class="fixed inset-0 z-50 flex items-center justify-center bg-black/50 px-4">
-    <div class="w-full max-w-md rounded-2xl bg-white p-6 shadow-xl">
-      <h3 class="text-lg font-semibold text-gray-900">Remove agent?</h3>
-      <p class="mt-2 text-sm text-gray-600">
-        Remove <strong>{{ pendingAgentRemoval?.user?.name || ('User #' + pendingAgentRemoval?.user_id) }}</strong>
-        from <strong>{{ pendingAgentRemoval?.group?.name }}</strong>?
-      </p>
-      <div class="mt-6 flex justify-end gap-2">
-        <button type="button" @click="closeRemoveAgentModal" class="text-sm text-gray-600 px-3 py-2 rounded-lg border border-gray-300 hover:bg-gray-100">Cancel</button>
-        <button type="button" @click="confirmRemoveAgent" class="bg-red-600 text-white text-sm px-4 py-2 rounded-lg hover:bg-red-700">Remove</button>
-      </div>
-    </div>
-  </div>
-
-  <div v-if="deletePriorityModalOpen" class="fixed inset-0 z-50 flex items-center justify-center bg-black/50 px-4">
-    <div class="w-full max-w-md rounded-2xl bg-white p-6 shadow-xl">
-      <h3 class="text-lg font-semibold text-gray-900">Delete priority?</h3>
-      <p class="mt-2 text-sm text-gray-600">
-        Delete <strong>{{ pendingPriorityDelete?.name }}</strong>? This cannot be undone.
-      </p>
-      <div class="mt-6 flex justify-end gap-2">
-        <button type="button" @click="closeDeletePriorityModal" class="text-sm text-gray-600 px-3 py-2 rounded-lg border border-gray-300 hover:bg-gray-100">Cancel</button>
-        <button type="button" @click="confirmDeletePriority" class="bg-red-600 text-white text-sm px-4 py-2 rounded-lg hover:bg-red-700">Delete</button>
-      </div>
-    </div>
-  </div>
-
-  <div v-if="deleteProjectModalOpen" class="fixed inset-0 z-50 flex items-center justify-center bg-black/50 px-4">
-    <div class="w-full max-w-md rounded-2xl bg-white p-6 shadow-xl">
-      <h3 class="text-lg font-semibold text-gray-900">Delete project?</h3>
-      <p class="mt-2 text-sm text-gray-600">
-        Delete <strong>{{ pendingProjectDelete?.name }}</strong>? This cannot be undone.
-      </p>
-      <div class="mt-6 flex justify-end gap-2">
-        <button type="button" @click="closeDeleteProjectModal" class="text-sm text-gray-600 px-3 py-2 rounded-lg border border-gray-300 hover:bg-gray-100">Cancel</button>
-        <button type="button" @click="confirmDeleteProject" class="bg-red-600 text-white text-sm px-4 py-2 rounded-lg hover:bg-red-700">Delete</button>
-      </div>
-    </div>
-  </div>
-</template>
-
-<script setup>
-import { ref } from 'vue'
-import { Link, useForm, router } from '@inertiajs/vue3'
-
-const props = defineProps({
-  groups: Array,
-  agents: Array,
-  priorities: Array,
-  projects: Array,
-  myGroupIds: Array,
-  isBootstrap: Boolean,
-  isSiteAdmin: Boolean,
-})
-
-const activeTab = ref('groups')
-const tabs = [
-  { key: 'groups', label: 'Groups' },
-  { key: 'agents', label: 'Agents' },
-  { key: 'priorities', label: 'Priorities' },
-  { key: 'projects', label: 'Projects' },
-]
-
-const showAddGroup = ref(false)
-const showAddAgent = ref(false)
-const showAddPriority = ref(false)
-const showAddProject = ref(false)
-const editingGroup = ref(null)
-const editingPriority = ref(null)
-const editingProject = ref(null)
-const removeAgentModalOpen = ref(false)
-const pendingAgentRemoval = ref(null)
-const deletePriorityModalOpen = ref(false)
-const pendingPriorityDelete = ref(null)
-const deleteProjectModalOpen = ref(false)
-const pendingProjectDelete = ref(null)
-
-const groupForm = useForm({ name: '', email_address: '', color: '#6366f1', prefix: '' })
-const editGroupForm = useForm({ name: '', email_address: '', color: '#6366f1', prefix: '' })
-const agentForm = useForm({ user_id: '', group_id: '', role: 'agent' })
-const priorityForm = useForm({ name: '', color: '#6b7280', description: '', sort_order: 0, group_id: null })
-const editPriorityForm = useForm({ name: '', color: '#6b7280', description: '', sort_order: 0, group_id: null })
-const projectForm = useForm({ group_id: '', name: '', description: '', status: 'active' })
-const editProjectForm = useForm({ name: '', description: '', status: 'active' })
-
-function submitGroup() {
-  groupForm.post(route('ticketing.settings.groups.store'), {
-    onSuccess: () => { showAddGroup.value = false; groupForm.reset() }
-  })
-}
-
-function startEditGroup(group) {
-  editingGroup.value = group
-  editGroupForm.name = group.name
-  editGroupForm.email_address = group.email_address || ''
-  editGroupForm.color = group.color
-  editGroupForm.prefix = group.prefix
-}
-
-function submitEditGroup() {
-  editGroupForm.put(route('ticketing.settings.groups.update', { group: editingGroup.value.id }), {
-    onSuccess: () => { editingGroup.value = null }
-  })
-}
-
-function submitAgent() {
-  agentForm.post(route('ticketing.settings.agents.store'), {
-    onSuccess: () => { showAddAgent.value = false; agentForm.reset() }
-  })
-}
-
-function openRemoveAgentModal(access) {
-  pendingAgentRemoval.value = access
-  removeAgentModalOpen.value = true
-}
-
-function closeRemoveAgentModal() {
-  removeAgentModalOpen.value = false
-  pendingAgentRemoval.value = null
-}
-
-function confirmRemoveAgent() {
-  if (!pendingAgentRemoval.value) return
-
-  router.delete(route('ticketing.settings.agents.destroy', { access: pendingAgentRemoval.value.id }), {
-    onFinish: closeRemoveAgentModal,
-  })
-}
-
-function submitPriority() {
-  priorityForm.post(route('ticketing.settings.priorities.store'), {
-    onSuccess: () => { showAddPriority.value = false; priorityForm.reset() }
-  })
-}
-
-function startEditPriority(priority) {
-  editingPriority.value = priority
-  editPriorityForm.name = priority.name
-  editPriorityForm.color = priority.color
-  editPriorityForm.description = priority.description || ''
-  editPriorityForm.sort_order = priority.sort_order
-  editPriorityForm.group_id = priority.group_id
-}
-
-function submitEditPriority() {
-  editPriorityForm.put(route('ticketing.settings.priorities.update', { priority: editingPriority.value.id }), {
-    onSuccess: () => { editingPriority.value = null }
-  })
-}
-
-function openDeletePriorityModal(priority) {
-  pendingPriorityDelete.value = priority
-  deletePriorityModalOpen.value = true
-}
-
-function closeDeletePriorityModal() {
-  deletePriorityModalOpen.value = false
-  pendingPriorityDelete.value = null
-}
-
-function confirmDeletePriority() {
-  if (!pendingPriorityDelete.value) return
-
-  router.delete(route('ticketing.settings.priorities.destroy', { priority: pendingPriorityDelete.value.id }), {
-    onFinish: closeDeletePriorityModal,
-  })
-}
-
-function submitProject() {
-  projectForm.post(route('ticketing.settings.projects.store'), {
-    onSuccess: () => { showAddProject.value = false; projectForm.reset() }
-  })
-}
-
-function startEditProject(project) {
-  editingProject.value = project
-  editProjectForm.name = project.name
-  editProjectForm.description = project.description || ''
-  editProjectForm.status = project.status
-}
-
-function submitEditProject() {
-  editProjectForm.put(route('ticketing.settings.projects.update', { project: editingProject.value.id }), {
-    onSuccess: () => { editingProject.value = null }
-  })
-}
-
-function openDeleteProjectModal(project) {
-  pendingProjectDelete.value = project
-  deleteProjectModalOpen.value = true
-}
-
-function closeDeleteProjectModal() {
-  deleteProjectModalOpen.value = false
-  pendingProjectDelete.value = null
-}
-
-function confirmDeleteProject() {
-  if (!pendingProjectDelete.value) return
-
-  router.delete(route('ticketing.settings.projects.destroy', { project: pendingProjectDelete.value.id }), {
-    onFinish: closeDeleteProjectModal,
-  })
-}
-</script>

resources/js/Pages/Ticketing/Show.vue

@@ -1,314 +0,0 @@
-<template>
-  <AppLayout>
-    <div class="max-w-4xl mx-auto">
-      <!-- Header -->
-      <div class="mb-6">
-        <Link :href="route('ticketing.index')" class="text-sm text-indigo-600 hover:underline">← Back to tickets</Link>
-      </div>
-
-      <div class="bg-white rounded-xl shadow-sm border border-gray-200">
-        <!-- Ticket Header -->
-        <div class="p-5 border-b border-gray-200">
-          <div class="flex items-start gap-3 flex-wrap">
-            <span
-              class="inline-block text-xs font-mono font-semibold px-2 py-1 rounded text-white flex-shrink-0"
-              :style="{ backgroundColor: ticket.group?.color || '#6366f1' }"
-            >
-              {{ ticket.number }}
-            </span>
-
-            <!-- Title (editable inline for agents) -->
-            <div class="flex-1 min-w-0">
-              <div v-if="editingTitle && isAgent" class="flex items-center gap-2">
-                <input
-                  v-model="titleEdit"
-                  class="flex-1 text-xl font-semibold border-b-2 border-indigo-400 bg-transparent focus:outline-none"
-                  @keyup.enter="saveTitle"
-                  @keyup.esc="editingTitle = false"
-                />
-                <button @click="saveTitle" class="text-xs text-green-600 hover:underline">Save</button>
-                <button @click="editingTitle = false" class="text-xs text-gray-400 hover:underline">Cancel</button>
-              </div>
-              <h1
-                v-else
-                class="text-xl font-semibold text-gray-900"
-                :class="{ 'cursor-pointer hover:text-indigo-600': isAgent }"
-                @click="isAgent && startEditTitle()"
-              >
-                {{ ticket.title }}
-                <span v-if="isAgent" class="ml-1 text-xs text-gray-400">✏️</span>
-              </h1>
-            </div>
-          </div>
-
-          <!-- Meta row -->
-          <div class="flex flex-wrap items-center gap-3 mt-3">
-            <!-- Status -->
-            <div>
-              <select
-                v-if="isAgent"
-                v-model="metaForm.status"
-                @change="saveMeta"
-                class="text-xs border-0 rounded-full px-3 py-1 font-medium cursor-pointer"
-                :class="statusClass(metaForm.status)"
-              >
-                <option v-for="s in statuses" :key="s.value" :value="s.value">{{ s.label }}</option>
-              </select>
-              <span v-else :class="statusClass(ticket.status)" class="inline-block text-xs px-2 py-1 rounded-full font-medium">
-                {{ statusLabel(ticket.status) }}
-              </span>
-            </div>
-
-            <!-- Priority -->
-            <div>
-              <select
-                v-if="isAgent"
-                v-model="metaForm.priority_id"
-                @change="saveMeta"
-                class="text-xs border border-gray-200 rounded-full px-3 py-1"
-              >
-                <option :value="null">No priority</option>
-                <option v-for="p in priorities" :key="p.id" :value="p.id">
-                  {{ p.name }}
-                </option>
-              </select>
-              <span v-else-if="ticket.priority" class="inline-flex items-center gap-1 text-xs text-gray-600">
-                <span class="w-2 h-2 rounded-full" :style="{ backgroundColor: ticket.priority.color }"></span>
-                {{ ticket.priority.name }}
-              </span>
-            </div>
-
-            <!-- Assignee -->
-            <div v-if="isAgent">
-              <select
-                v-model="metaForm.assigned_to"
-                @change="saveMeta"
-                class="text-xs border border-gray-200 rounded-full px-3 py-1"
-              >
-                <option :value="null">Unassigned</option>
-                <option v-for="a in agents" :key="a.id" :value="a.id">{{ a.name }}</option>
-              </select>
-            </div>
-
-            <!-- Due date -->
-            <div class="flex items-center gap-1 text-xs text-gray-500">
-              <span>📅</span>
-              <input
-                v-if="isAgent"
-                v-model="metaForm.due_date"
-                type="date"
-                @change="saveMeta"
-                class="text-xs border-0 bg-transparent cursor-pointer p-0"
-              />
-              <span v-else>{{ ticket.due_date || 'No due date' }}</span>
-            </div>
-
-            <!-- Edit / Delete actions -->
-            <div class="ml-auto flex gap-2">
-              <Link
-                v-if="isAgent"
-                :href="route('ticketing.edit', { ticket: ticket.id })"
-                class="text-xs text-indigo-600 hover:underline"
-              >Edit</Link>
-              <button
-                v-if="isManager"
-                @click="confirmDelete"
-                class="text-xs text-red-500 hover:underline"
-              >Delete</button>
-            </div>
-          </div>
-        </div>
-
-        <!-- Message Thread -->
-        <div class="p-5 space-y-4 max-h-[60vh] overflow-y-auto">
-          <div v-if="ticket.messages.length === 0" class="text-sm text-gray-400 text-center py-8">
-            No messages yet.
-          </div>
-
-          <div
-            v-for="msg in ticket.messages"
-            :key="msg.id"
-            :class="['flex', isOwnMessage(msg) ? 'justify-end' : 'justify-start']"
-          >
-            <div
-              :class="[
-                'max-w-[75%] rounded-xl px-4 py-2.5 text-sm',
-                msg.is_internal
-                  ? 'bg-amber-50 border border-amber-200 text-amber-900'
-                  : isOwnMessage(msg)
-                    ? 'bg-indigo-600 text-white'
-                    : 'bg-gray-100 text-gray-800'
-              ]"
-            >
-              <div class="flex items-center gap-2 mb-1 text-xs opacity-70">
-                <span v-if="msg.is_internal">🔒 Internal Note · </span>
-                <span>{{ msg.author?.name || msg.author_email || 'Unknown' }}</span>
-                <span>· {{ timeAgo(msg.created_at) }}</span>
-              </div>
-              <p class="whitespace-pre-wrap">{{ msg.body }}</p>
-            </div>
-          </div>
-        </div>
-
-        <!-- Reply Area -->
-        <div class="border-t border-gray-200 p-5">
-          <!-- Tab switcher (agents only) -->
-          <div v-if="isAgent" class="flex gap-2 mb-3">
-            <button
-              @click="replyTab = 'reply'"
-              :class="[
-                'text-xs px-3 py-1.5 rounded-md font-medium transition',
-                replyTab === 'reply' ? 'bg-indigo-600 text-white' : 'bg-gray-100 text-gray-600 hover:bg-gray-200'
-              ]"
-            >Reply to submitter</button>
-            <button
-              @click="replyTab = 'internal'"
-              :class="[
-                'text-xs px-3 py-1.5 rounded-md font-medium transition',
-                replyTab === 'internal' ? 'bg-amber-500 text-white' : 'bg-gray-100 text-gray-600 hover:bg-gray-200'
-              ]"
-            >🔒 Internal Note</button>
-          </div>
-
-          <form @submit.prevent="sendMessage">
-            <textarea
-              v-model="messageForm.body"
-              required
-              rows="3"
-              :placeholder="replyTab === 'internal' ? 'Internal note — only visible to agents…' : 'Type your reply…'"
-              :class="[
-                'w-full rounded-lg text-sm border',
-                replyTab === 'internal'
-                  ? 'border-amber-300 bg-amber-50'
-                  : 'border-gray-300'
-              ]"
-            ></textarea>
-
-            <div class="flex items-center justify-between mt-3">
-              <label class="flex items-center gap-2 text-xs text-gray-500 cursor-pointer">
-                <input type="file" class="hidden" @change="attachFile" />
-                <span class="text-gray-400 hover:text-indigo-600 transition">📎 Attach file</span>
-              </label>
-              <button
-                type="submit"
-                :disabled="messageForm.processing"
-                :class="[
-                  'inline-flex items-center gap-1 text-sm font-medium px-4 py-2 rounded-lg transition',
-                  replyTab === 'internal'
-                    ? 'bg-amber-500 text-white hover:bg-amber-600 disabled:opacity-60'
-                    : 'bg-gray-900 text-white hover:bg-gray-700 disabled:opacity-60'
-                ]"
-              >
-                {{ messageForm.processing ? 'Sending…' : 'Send' }}
-              </button>
-            </div>
-          </form>
-        </div>
-      </div>
-    </div>
-  </AppLayout>
-</template>
-
-<script setup>
-import { ref } from 'vue'
-import { Link, useForm, router } from '@inertiajs/vue3'
-import AppLayout from '@/Layouts/AppLayout.vue'
-
-const props = defineProps({
-  ticket: Object,
-  isAgent: Boolean,
-  isManager: Boolean,
-  agents: Array,
-  priorities: Array,
-})
-
-const replyTab = ref('reply')
-const editingTitle = ref(false)
-const titleEdit = ref(props.ticket.title)
-
-const statuses = [
-  { value: 'open', label: 'Open' },
-  { value: 'in_progress', label: 'In Progress' },
-  { value: 'pending', label: 'Pending' },
-  { value: 'resolved', label: 'Resolved' },
-  { value: 'closed', label: 'Closed' },
-]
-
-const metaForm = useForm({
-  status: props.ticket.status,
-  priority_id: props.ticket.priority_id,
-  assigned_to: props.ticket.assigned_to,
-  due_date: props.ticket.due_date,
-})
-
-const messageForm = useForm({
-  body: '',
-  is_internal: false,
-})
-
-function isOwnMessage(msg) {
-  return !props.isAgent ? msg.user_id === props.ticket.submitter_id : msg.user_id !== props.ticket.submitter_id
-}
-
-function startEditTitle() {
-  titleEdit.value = props.ticket.title
-  editingTitle.value = true
-}
-
-function saveTitle() {
-  router.put(route('ticketing.update', { ticket: props.ticket.id }), { title: titleEdit.value }, {
-    onSuccess: () => { editingTitle.value = false }
-  })
-}
-
-function saveMeta() {
-  metaForm.put(route('ticketing.update', { ticket: props.ticket.id }))
-}
-
-function sendMessage() {
-  messageForm.is_internal = replyTab.value === 'internal'
-  messageForm.post(route('ticketing.messages.store', { ticket: props.ticket.id }), {
-    onSuccess: () => { messageForm.body = '' }
-  })
-}
-
-function attachFile(event) {
-  const file = event.target.files[0]
-  if (!file) return
-  const data = new FormData()
-  data.append('file', file)
-  router.post(route('ticketing.attachments.store', { ticket: props.ticket.id }), data)
-}
-
-function confirmDelete() {
-  if (confirm(`Delete ticket ${props.ticket.number}? This cannot be undone.`)) {
-    router.delete(route('ticketing.destroy', { ticket: props.ticket.id }))
-  }
-}
-
-function statusLabel(status) {
-  const map = { open: 'Open', in_progress: 'In Progress', pending: 'Pending', resolved: 'Resolved', closed: 'Closed' }
-  return map[status] || status
-}
-
-function statusClass(status) {
-  const map = {
-    open: 'bg-blue-100 text-blue-700',
-    in_progress: 'bg-purple-100 text-purple-700',
-    pending: 'bg-yellow-100 text-yellow-700',
-    resolved: 'bg-green-100 text-green-700',
-    closed: 'bg-gray-100 text-gray-500',
-  }
-  return map[status] || 'bg-gray-100 text-gray-600'
-}
-
-function timeAgo(dateStr) {
-  const date = new Date(dateStr)
-  const now = new Date()
-  const diff = Math.floor((now - date) / 1000)
-  if (diff < 60) return `${diff}s ago`
-  if (diff < 3600) return `${Math.floor(diff / 60)}m ago`
-  if (diff < 86400) return `${Math.floor(diff / 3600)}h ago`
-  return `${Math.floor(diff / 86400)}d ago`
-}
-</script>

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/Console/Commands/RepairMergedTickets.php

@@ -0,0 +1,67 @@
+<?php
+
+namespace Dashboard\Ticketing\Console\Commands;
+
+use Dashboard\Ticketing\Support\MergedTicketRepair;
+use Illuminate\Console\Command;
+
+/**
+ * THE DRY-RUN COUNT, AND THE REPAIR — [central-ticketing] #938.
+ *
+ * The first question #938 asks is a number: how many rows on prod carry
+ * `merged_into_id` with a status other than `merged`. That number decides
+ * whether the office corrects them one at a time from the badge or whether a
+ * deploy re-marks them all, and there was no way to ask for it that did not
+ * involve typing a raw UPDATE-shaped statement into tinker on the production
+ * box. So `--dry-run` is the default and is the point of this command:
+ *
+ *     php artisan ticketing:repair-merged --dry-run    # count + list, writes NOTHING
+ *     php artisan ticketing:repair-merged --force      # re-mark them all
+ *
+ * `--force` is required to write, rather than `--dry-run` being required not
+ * to. A repair command whose bare form repairs is one fat-finger away from
+ * being the incident it was written to clean up after.
+ */
+class RepairMergedTickets extends Command
+{
+    protected $signature = 'ticketing:repair-merged
+                            {--dry-run : Count and list the inconsistent rows; write nothing (the default).}
+                            {--force : Actually re-mark every inconsistent row as merged.}';
+
+    protected $description = 'Report — or, with --force, repair — tickets whose merged_into_id is set while their status is not "merged" (#938).';
+
+    public function handle(): int
+    {
+        $rows = MergedTicketRepair::rows();
+
+        $this->line(sprintf(
+            'SELECT COUNT(*) FROM tickets WHERE merged_into_id IS NOT NULL AND status <> \'merged\' => %d',
+            $rows->count(),
+        ));
+
+        if ($rows->isEmpty()) {
+            $this->info('Nothing is inconsistent. No repair to make.');
+
+            return 0;
+        }
+
+        $this->table(
+            ['id', 'number', 'status', 'merged_into_id', 'updated_at'],
+            $rows->map(fn ($t) => [
+                $t->id, $t->number, $t->status, $t->merged_into_id, (string) $t->updated_at,
+            ])->all(),
+        );
+
+        if (! $this->option('force')) {
+            $this->comment('Dry run — nothing was written. Re-run with --force to re-mark these as merged.');
+
+            return 0;
+        }
+
+        $changed = MergedTicketRepair::repairAll('artisan ticketing:repair-merged');
+
+        $this->info("Re-marked {$changed} ticket(s) as merged. Their messages and participants are untouched.");
+
+        return 0;
+    }
+}

src/Http/Controllers/TicketAttachmentController.php

@@ -29,6 +29,11 @@ class TicketAttachmentController extends Controller
             abort(403);
         }
 
+        // Same read-only rule as a reply — see TicketMessageController::store(). #920
+        if ($ticket->isMerged()) {
+            return back()->withErrors(['ticket' => Ticket::READ_ONLY_REASON]);
+        }
+
         $request->validate([
             'file' => 'required|file|max:' . (self::MAX_SIZE_MB * 1024),
             // Bug #5: message_id must belong to THIS ticket, not any arbitrary message
@@ -49,7 +54,7 @@ class TicketAttachmentController extends Controller
         ]);
 
         $file = $request->file('file');
-        $disk = config('ticketing.storage_disk', env('TICKETING_STORAGE_DISK', 'local'));
+        $disk = config('ticketing.storage_disk', 'local');
         $path = $file->store('ticketing/attachments/' . $ticket->id, $disk);
 
         TicketAttachment::create([
@@ -71,7 +76,7 @@ class TicketAttachmentController extends Controller
             abort(403);
         }
 
-        $disk = config('ticketing.storage_disk', env('TICKETING_STORAGE_DISK', 'local'));
+        $disk = config('ticketing.storage_disk', 'local');
         return Storage::disk($disk)->download($attachment->path, $attachment->filename);
     }
 }

src/Http/Controllers/TicketController.php

@@ -3,6 +3,9 @@
 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;
@@ -13,15 +16,25 @@ use Dashboard\Ticketing\Models\TicketMessage;
 use Dashboard\Ticketing\Models\TicketParticipant;
 use Dashboard\Ticketing\Models\TicketStatus;
 use Dashboard\Ticketing\Models\TicketView;
+use Dashboard\Ticketing\Support\MergedTicketRepair;
+use Dashboard\Ticketing\Support\StrandedMerge;
 use Illuminate\Http\Request;
 use Illuminate\Routing\Controller;
 use Illuminate\Support\Facades\Auth;
 use Illuminate\Support\Facades\DB;
+use Illuminate\Validation\Rule;
 use Inertia\Inertia;
 use Inertia\Response;
 
 class TicketController extends Controller
 {
+    /**
+     * The sidebar's views, and the only values `?filter=` means anything as.
+     * Index.vue's `visibleViews` draws exactly these; `savePrefs()` validates
+     * against them; `index()` normalises anything else to `all` (#1054).
+     */
+    private const VIEW_FILTERS = ['all', 'mine', 'unassigned', 'pending', 'resolved', 'merged'];
+
     private function agentGroupIds(): array
     {
         return TicketingAgentAccess::where('user_id', Auth::id())
@@ -46,6 +59,40 @@ class TicketController extends Controller
             ->exists();
     }
 
+    /**
+     * REFUSE A WRITE TO A MERGED TICKET — [central-ticketing] #920.
+     *
+     * The Show page has always announced "This ticket has been merged and is
+     * read-only." and hidden the reply composer and the Merge button. Nothing
+     * enforced it: the Edit form was still linked, still rendered (with its Status
+     * select blank, because `merged` is not one of its options), and `update()`
+     * happily wrote `status = open` while leaving `merged_into_id` pointing at the
+     * target. That produced a ticket that was live and assignable in the All Open
+     * queue and simultaneously merged into another one, with none of its own
+     * messages — an empty duplicate of the ticket it had been folded into.
+     *
+     * So the check lives HERE, on the server, once, and every write path that the
+     * page presents as unavailable calls it. Returning a refusal rather than
+     * `abort(403)` on purpose: the realistic way to arrive here is a page that was
+     * already open when somebody else merged the ticket, and that operator is
+     * better served by the reason on the ticket than by an error screen.
+     * `FormErrors` renders any key it is handed, so the sentence shows up.
+     *
+     * @return \Illuminate\Http\RedirectResponse|null  null when the write may proceed
+     */
+    private function refuseIfMerged(Ticket $ticket, bool $stayPut = false)
+    {
+        if (! $ticket->isMerged()) {
+            return null;
+        }
+
+        $errors = ['ticket' => Ticket::READ_ONLY_REASON];
+
+        return $stayPut
+            ? back()->withErrors($errors)
+            : redirect()->route('ticketing.show', $ticket)->withErrors($errors);
+    }
+
     /**
      * Filter messages for submitters — strip internal notes.
      */
@@ -76,6 +123,18 @@ class TicketController extends Controller
             $request->merge(['filter' => $pref['filter']]);
         }
 
+        // #1054 — a `filter` the sidebar has no view for used to fall through to
+        // the All Open branch and then be echoed straight back in `props.filters`,
+        // so `?filter=closed` looked like a real view that just happened to be
+        // showing open tickets. There is no Closed view anywhere in the UI;
+        // anything unrecognised is All Open, and now says so. The list is the
+        // one `savePrefs()` validates against and the one Index.vue draws.
+        // Only rewrites a filter that was actually asked for: an absent one keeps
+        // meaning "no view chosen", which is what leaves `filter` out of the URL.
+        if ($request->filled('filter') && ! in_array($request->filter, self::VIEW_FILTERS, true)) {
+            $request->merge(['filter' => 'all']);
+        }
+
         // If no groups exist at all, render a first-run / bootstrap state
         $totalGroups = TicketingGroup::count();
         if ($totalGroups === 0) {
@@ -112,6 +171,13 @@ class TicketController extends Controller
                 'unassigned' => (clone $baseQuery)->whereNull('assigned_to')->whereNotIn('status', $closedSlugs)->count(),
                 'pending' => (clone $baseQuery)->where('status', 'pending')->count(),
                 'resolved' => (clone $baseQuery)->whereIn('status', $closedSlugs)->count(),
+                // #938: the pointer, not the status — this view exists to show the
+                // rows where the two disagree, so filtering by `status = merged`
+                // would hide exactly the ones worth looking at. #1567: nor is the
+                // pointer alone enough, because a stranded row has neither a
+                // target nor a disagreeing status. Either mark of a merge counts.
+                'merged' => (clone $baseQuery)->everMerged()->count(),
+                'merged_inconsistent' => (clone $baseQuery)->mergeInconsistent()->count(),
             ]
             : [
                 'all' => (clone $baseQuery)->count(),
@@ -119,6 +185,8 @@ class TicketController extends Controller
                 'unassigned' => 0,
                 'pending' => (clone $baseQuery)->where('status', 'pending')->count(),
                 'resolved' => (clone $baseQuery)->whereIn('status', $closedSlugs)->count(),
+                'merged' => 0,
+                'merged_inconsistent' => 0,
             ];
 
         $query = Ticket::with(['group', 'priority', 'project']);
@@ -138,14 +206,36 @@ class TicketController extends Controller
             if ($request->filled('project_id')) {
                 $query->where('project_id', $request->project_id);
             }
+            // #1054 — the work queues scope by `$closedSlugs`, the same list the
+            // counts above use. They used to spell it `['resolved', 'closed']`
+            // by hand, which predates the `merged` status: a correctly merged
+            // ticket stayed in Unassigned as pickable work while the sidebar
+            // count next to it — already reading `$closedSlugs` — excluded it,
+            // so the view disagreed with its own header (4 vs 5). Scoping by
+            // STATUS and not by `merged_into_id` is deliberate: #938's
+            // inconsistent rows (pointer set, status still open) are live work
+            // until somebody repairs them, and hiding them from the queue would
+            // hide the rows that most need a human.
             if ($request->filter === 'mine') {
-                $query->where('assigned_to', $user->id)->whereNotIn('status', ['resolved', 'closed']);
+                $query->where('assigned_to', $user->id)->whereNotIn('status', $closedSlugs);
             } elseif ($request->filter === 'unassigned') {
-                $query->whereNull('assigned_to')->whereNotIn('status', ['resolved', 'closed']);
+                $query->whereNull('assigned_to')->whereNotIn('status', $closedSlugs);
             } elseif ($request->filter === 'pending') {
                 $query->where('status', 'pending');
             } elseif ($request->filter === 'resolved') {
                 $query->whereIn('status', $closedSlugs);
+            } elseif ($request->filter === 'merged') {
+                // Every ticket that has been folded into another one, whatever its
+                // status says — which is what makes this the place the office
+                // finds the rows #938 is about. `merged` is a closed slug, so the
+                // whereNotIn below would drop the consistent half of the list.
+                //
+                // #1567 — and whatever its POINTER says, too. Scoping by the
+                // pointer alone dropped a ticket whose merge target had been
+                // deleted out of this view entirely (n went 1 → 0 on the delete),
+                // leaving it visible only under Resolved: the rows most in need of
+                // a human were the ones the view could not show.
+                $query->everMerged();
             } elseif (!$request->filled('status')) {
                 $query->whereNotIn('status', $closedSlugs);
             }
@@ -172,7 +262,14 @@ class TicketController extends Controller
             return $ticket;
         });
 
-        $groups = TicketingGroup::when($isAgent, fn ($q) => $q->whereIn('id', $agentGroupIds))->get();
+        // Picker data: the group switcher/filter and the detail pane's transfer
+        // select both read this, so archived groups are excluded. The tickets
+        // themselves are NOT filtered — an archived group's tickets stay in the
+        // list and stay workable; Index.vue re-adds the current group to the
+        // transfer options when it happens to be archived.
+        $groups = TicketingGroup::active()
+            ->when($isAgent, fn ($q) => $q->whereIn('id', $agentGroupIds))
+            ->get();
         $priorities = PriorityLevel::orderBy('sort_order')->get();
         $projects = TicketingProject::when($isAgent, fn ($q) => $q->whereIn('group_id', $agentGroupIds))
             ->where('status', 'active')
@@ -269,7 +366,10 @@ class TicketController extends Controller
         $agentGroupIds = $this->agentGroupIds();
         $isAgent = count($agentGroupIds) > 0;
 
-        $groups = TicketingGroup::when($isAgent, fn($q) => $q->whereIn('id', $agentGroupIds))->get();
+        // New tickets can only be filed against a live group.
+        $groups = TicketingGroup::active()
+            ->when($isAgent, fn($q) => $q->whereIn('id', $agentGroupIds))
+            ->get();
 
         // No groups at all? Show first-run state.
         if ($groups->isEmpty() && TicketingGroup::count() === 0) {
@@ -296,8 +396,18 @@ class TicketController extends Controller
         $validated = $request->validate([
             'title' => 'required|string|max:255',
             'description' => 'required|string',
-            'group_id' => 'required|exists:ticketing_groups,id',
-            'priority_id' => 'nullable|exists:ticketing_priority_levels,id',
+            // Archived groups are gone from the picker; they must also be
+            // unreachable by posting a stale id.
+            //
+            // `integer` before `exists` is load-bearing, not tidiness: `exists`
+            // given an ARRAY checks that every element exists, so `group_id: [14]`
+            // sailed through with one valid id and reached the controller as an
+            // array. findOrFail() then returned a Collection, ->nextTicketNumber()
+            // on it fatalled, and the endpoint 500'd instead of 422ing. Only some
+            // array shapes showed it — `['a','b']` was rejected by exists itself,
+            // which is why this hid behind a passing validation rule.
+            'group_id' => ['required', 'integer', Rule::exists('ticketing_groups', 'id')->whereNull('archived_at')],
+            'priority_id' => 'nullable|integer|exists:ticketing_priority_levels,id',
             'due_date' => 'nullable|date',
             'attachments' => 'nullable|array|max:5',
             'attachments.*' => 'file|max:20480',
@@ -322,7 +432,7 @@ class TicketController extends Controller
         ]);
 
         if ($request->hasFile('attachments')) {
-            $disk = config('ticketing.storage_disk', env('TICKETING_STORAGE_DISK', 'local'));
+            $disk = config('ticketing.storage_disk', 'local');
             foreach ($request->file('attachments') as $file) {
                 if (!$file->isValid()) continue;
                 $path = $file->store('ticketing/attachments/' . $ticket->id, $disk);
@@ -361,7 +471,39 @@ class TicketController extends Controller
             ->push($ticket->submitter_id)
             ->push($ticket->assigned_to)
             ->filter()->unique();
-        $users = DB::table('users')->whereIn('id', $userIds)->get(['id', 'name', 'email'])->keyBy('id');
+        /*
+         * EVERY PERSON ON THIS PAGE, IN THE PLATFORM'S ROW SHAPE (#1598).
+         *
+         * This was `DB::table('users')->get(['id', 'name', 'email'])`, and the
+         * Participants card it feeds drew each of those as
+         * `{{ p.user?.name || p.user?.email }}` — a bare text row where the rest
+         * of the platform draws a chip. `PersonChip::rows()` is the shared
+         * serializer, so what those rows SAY is the operator's chip setting
+         * rather than this method's select list, and it is the same payload the
+         * participant SEARCH answers with: the person picked and the row they
+         * were picked from cannot disagree about what they are called.
+         *
+         * `rows()` AND NOT THE MODEL. This map also feeds the message bylines
+         * and the assignee, so a `User` handed straight to Inertia would put
+         * every column of `users` — `preferred_pin`, `preferred_password`,
+         * `date_of_birth` — on the page for anybody who has ever replied to a
+         * ticket. `rows()` is exactly `{id, name, email, person}`, and `person`
+         * is the curated allow-list `PersonChip::FIELDS` describes.
+         *
+         * ONE BULK PASS for the whole page: `forMany()` inside `rows()` reads
+         * the alias catalogue and the school year once for the collection, and a
+         * chip built per row would repeat that for every participant, every
+         * message author and the assignee on a fifty-reply thread.
+         *
+         * `PersonChip::columns()` is the select list because a chip line may
+         * name ANY user column, and a constrained select hands the helper a
+         * model whose attribute is simply absent — which it cannot tell from a
+         * person who has no value, so the line goes blank for everybody with
+         * nothing failing.
+         */
+        $users = collect(PersonChip::rows(
+            User::whereIn('id', $userIds)->get(PersonChip::columns())
+        ))->keyBy('id');
 
         $visibleMessages->each(function ($msg) use ($users) {
             $msg->author = $msg->user_id ? ($users[$msg->user_id] ?? null) : null;
@@ -393,15 +535,35 @@ class TicketController extends Controller
             'agents'         => $agents,
             'priorities'     => $priorities,
             'ticketStatuses' => TicketStatus::orderBy('sort_order')->get(),
+            /*
+             * WHAT DELETING THIS WOULD TAKE WITH IT — #1567.
+             *
+             * The delete confirm was the generic "This cannot be undone.", which
+             * told an agent tidying up the surviving ticket of a merge nothing
+             * about the tickets folded into it. `destroy()` now un-merges them
+             * rather than stranding them, and this is how the confirm can say so
+             * before the click. Numbers only, and only for the manager who is
+             * offered Delete at all.
+             */
+            'mergedSources'  => $isAgent && $this->isManager($ticket->group_id)
+                ? Ticket::where('merged_into_id', $ticket->id)
+                    ->where('status', Ticket::STATUS_MERGED)
+                    ->orderBy('id')->pluck('number')->all()
+                : [],
         ]);
     }
 
-    public function edit(Ticket $ticket): Response
+    /** @return Response|\Illuminate\Http\RedirectResponse — merged tickets are sent back to Show. */
+    public function edit(Ticket $ticket)
     {
         if (!$this->isAgent($ticket->group_id)) {
             abort(403);
         }
 
+        if ($refusal = $this->refuseIfMerged($ticket)) {
+            return $refusal;
+        }
+
         $ticket->load(['group', 'priority', 'project']);
         $priorities = PriorityLevel::orderBy('sort_order')->get();
         $agentIds = TicketingAgentAccess::where('group_id', $ticket->group_id)->pluck('user_id');
@@ -413,6 +575,16 @@ class TicketController extends Controller
             'priorities' => $priorities,
             'agents' => $agents,
             'projects' => $projects,
+            /*
+             * The form's Status select used to hard-code five slugs, so any ticket
+             * whose status was not one of them — `merged`, or any status added on
+             * the Statuses settings tab — rendered with nothing selected and the
+             * first save silently rewrote the status to whatever the operator
+             * happened to leave showing. Same defect as #920, one layer up: drive
+             * the options from the same table `update()` validates against.
+             */
+            'ticketStatuses' => TicketStatus::where('slug', '!=', Ticket::STATUS_MERGED)
+                ->orderBy('sort_order')->get(),
         ]);
     }
 
@@ -422,6 +594,10 @@ class TicketController extends Controller
             abort(403);
         }
 
+        if ($refusal = $this->refuseIfMerged($ticket)) {
+            return $refusal;
+        }
+
         // Determine effective group (may be changing via a transfer)
         $targetGroupId = $request->filled('group_id')
             ? (int) $request->input('group_id')
@@ -433,16 +609,29 @@ class TicketController extends Controller
             ->toArray();
 
         // Build valid status list from DB (exclude 'merged' — set only by the merge operation)
-        $validStatusSlugs = TicketStatus::where('slug', '!=', 'merged')->pluck('slug')->implode(',');
+        $validStatusSlugs = TicketStatus::where('slug', '!=', Ticket::STATUS_MERGED)->pluck('slug')->implode(',');
 
         $rules = [
             'title'       => 'sometimes|required|string|max:255',
             'description' => 'sometimes|required|string',
             'status'      => "sometimes|in:{$validStatusSlugs}",
-            'priority_id' => 'nullable|exists:ticketing_priority_levels,id',
+            // `integer` guards the same array-through-`exists` hole as store().
+            'priority_id' => 'nullable|integer|exists:ticketing_priority_levels,id',
             'due_date'    => 'nullable|date',
-            'project_id'  => 'nullable|exists:ticketing_projects,id',
-            'group_id'    => 'nullable|exists:ticketing_groups,id',
+            'project_id'  => 'nullable|integer|exists:ticketing_projects,id',
+            // A ticket may not be transferred INTO an archived group, but a
+            // ticket already sitting in one must still be editable — so its own
+            // group id always validates.
+            'group_id'    => ['nullable', 'integer', 'exists:ticketing_groups,id',
+                function ($attribute, $value, $fail) use ($ticket) {
+                    if (! $value || (int) $value === (int) $ticket->group_id) {
+                        return;
+                    }
+                    if (TicketingGroup::whereKey($value)->archived()->exists()) {
+                        $fail('That group is archived — choose an active group.');
+                    }
+                },
+            ],
             'assigned_to' => 'nullable|in:' . implode(',', $validAssigneeIds ?: [0]),
         ];
 
@@ -468,8 +657,34 @@ class TicketController extends Controller
             }
         }
 
+        // Issue #8: capture the previous assignee BEFORE the write, so a genuine
+        // hand-off can be told from a save that merely touched other fields.
+        $previousAssignee = $ticket->assigned_to;
+
         $ticket->update($validated);
 
+        $newAssignee = $ticket->assigned_to;
+        $handedOver = $newAssignee
+            && $newAssignee !== $previousAssignee
+            && $newAssignee !== Auth::id();     // assigning to yourself needs no telling
+
+        if ($handedOver) {
+            $agent = \App\Models\User::find($newAssignee);
+
+            // The agent, not their address — see TicketingNotifier::deliver().
+            // A bare string loses to_user_id and to_name and skips the opt-out.
+            if ($agent) {
+                \Dashboard\Ticketing\Support\TicketingNotifier::deliver(
+                    \Dashboard\Ticketing\Support\TicketingNotifier::ASSIGNED,
+                    $agent,
+                    "[{$ticket->number}] Assigned to you: {$ticket->title}",
+                    '<p>'.e(Auth::user()?->name ?? 'Somebody').' assigned this ticket to you.</p>'
+                        .'<p><a href="'.e(route('ticketing.show', $ticket->id)).'">View the ticket</a></p>',
+                    $ticket,
+                );
+            }
+        }
+
         return back()->with('success', 'Ticket updated.');
     }
 
@@ -503,7 +718,7 @@ class TicketController extends Controller
     {
         $validated = $request->validate([
             'view_mode' => 'sometimes|in:list,kanban',
-            'filter'    => 'sometimes|in:all,mine,unassigned,pending,resolved',
+            'filter'    => 'sometimes|in:'.implode(',', self::VIEW_FILTERS),
         ]);
 
         if (empty($validated)) {
@@ -517,14 +732,112 @@ class TicketController extends Controller
         return response()->json(['ok' => true]);
     }
 
+    /**
+     * DELETE, WITHOUT STRANDING WHAT WAS MERGED IN — [central-ticketing] #1567.
+     *
+     * `merged_into_id` is `nullOnDelete()`, so this used to be a one-liner that
+     * quietly broke every ticket folded into the row it deleted: pointer blanked,
+     * `status = 'merged'` left behind, permanently read-only, missing from the
+     * Merged view. {@see StrandedMerge::handleTargetDeletion()} is the whole fix,
+     * and it runs INSIDE the transaction and BEFORE the delete — it needs the
+     * doomed row's number for the system notes it writes, and its own
+     * `merged_into_id` to re-point the sources up the chain.
+     *
+     * The flash names what happened, because the agent who deleted this ticket
+     * was not looking at those tickets and has no other way to find out.
+     */
     public function destroy(Ticket $ticket)
     {
         if (!$this->isManager($ticket->group_id)) {
             abort(403);
         }
 
-        $ticket->delete();
-        return redirect()->route('ticketing.index');
+        $number = $ticket->number;
+
+        $handled = DB::transaction(function () use ($ticket) {
+            $handled = StrandedMerge::handleTargetDeletion($ticket, 'user '.Auth::id());
+            $ticket->delete();
+
+            return $handled;
+        });
+
+        return redirect()->route('ticketing.index')
+            ->with('success', $this->deletionFlash($number, $handled));
+    }
+
+    /**
+     * One sentence per thing that happened to somebody else's ticket. #1567.
+     *
+     * @param array{repointed: list<string>, unmerged: list<string>, cleared: list<string>} $handled
+     */
+    private function deletionFlash(string $number, array $handled): string
+    {
+        $parts = ["Ticket {$number} deleted."];
+
+        if ($handled['unmerged'] !== []) {
+            $parts[] = sprintf(
+                '%s %s merged into it and %s been un-merged (status %s) so %s usable: %s.',
+                count($handled['unmerged']),
+                count($handled['unmerged']) === 1 ? 'ticket was' : 'tickets were',
+                count($handled['unmerged']) === 1 ? 'has' : 'have',
+                Ticket::STATUS_UNMERGED,
+                // The verb agrees with the pronoun, so it lives in the same ternary:
+                // "so it stays usable" / "so they stay usable".
+                count($handled['unmerged']) === 1 ? 'it stays' : 'they stay',
+                implode(', ', $handled['unmerged']),
+            );
+        }
+
+        if ($handled['repointed'] !== []) {
+            $parts[] = sprintf(
+                '%s %s merged into it and %s now recorded as merged into its own merge target: %s.',
+                count($handled['repointed']),
+                count($handled['repointed']) === 1 ? 'ticket was' : 'tickets were',
+                count($handled['repointed']) === 1 ? 'is' : 'are',
+                implode(', ', $handled['repointed']),
+            );
+        }
+
+        return implode(' ', $parts);
+    }
+
+    /**
+     * UN-MERGE A STRANDED TICKET — [central-ticketing] #1567.
+     *
+     * The recovery for the rows minted before `destroy()` learned to clean up
+     * after itself: `status = 'merged'` with no `merged_into_id`, read-only on the
+     * server (#920 reads the status) and pointing at nothing, so there was no
+     * sequence of clicks that could free one. This is that sequence.
+     *
+     * Scoped to {@see Ticket::isStrandedMerge()} and nothing else, so it cannot be
+     * used to un-merge a LIVE merge — a ticket whose target still exists is
+     * correctly read-only and stays that way.
+     */
+    public function unmerge(Ticket $ticket)
+    {
+        if (! $this->isAgent($ticket->group_id)) {
+            abort(403);
+        }
+
+        if (! $ticket->isStrandedMerge()) {
+            // Not an error: the button only renders on a stranded row, so getting
+            // here means a colleague already dealt with it, or the ticket is
+            // merged into something that still exists.
+            return redirect()->route('ticketing.show', $ticket)
+                ->with('success', $ticket->isMerged()
+                    ? 'That ticket is merged into a ticket that still exists — nothing to un-merge.'
+                    : 'That ticket is not merged — nothing to un-merge.');
+        }
+
+        StrandedMerge::release(
+            $ticket,
+            'The ticket this one had been merged into no longer exists, so this ticket was '
+            .'un-merged and is editable again.',
+            'user '.Auth::id(),
+        );
+
+        return redirect()->route('ticketing.show', $ticket)
+            ->with('success', "Ticket {$ticket->number} is un-merged and is no longer read-only.");
     }
 
     /**
@@ -549,7 +862,7 @@ class TicketController extends Controller
         if ($source->id === $ticket->id) {
             return back()->withErrors(['source_number' => 'Cannot merge a ticket into itself.']);
         }
-        if ($source->status === 'merged') {
+        if ($source->isMerged()) {
             return back()->withErrors(['source_number' => 'That ticket has already been merged.']);
         }
         if (! $this->isAgent($source->group_id)) {
@@ -566,13 +879,7 @@ class TicketController extends Controller
                 ->update(['ticket_id' => $ticket->id]);
 
             // Add a system note marking the merge
-            TicketMessage::create([
-                'ticket_id'   => $ticket->id,
-                'user_id'     => Auth::id(),
-                'body'        => "Merged from ticket {$source->number}.",
-                'is_internal' => true,
-                'source'      => 'system',
-            ]);
+            TicketMessage::system($ticket, "Merged from ticket {$source->number}.");
 
             // Add source's submitter as a participant (if not already the submitter of target)
             if ($source->submitter_id !== $ticket->submitter_id) {
@@ -584,7 +891,7 @@ class TicketController extends Controller
 
             // Mark source as merged
             $source->update([
-                'status'         => 'merged',
+                'status'         => Ticket::STATUS_MERGED,
                 'merged_into_id' => $ticket->id,
             ]);
         });
@@ -593,6 +900,48 @@ class TicketController extends Controller
             ->with('success', "Ticket {$source->number} merged in.");
     }
 
+    /**
+     * MARK ONE INCONSISTENT ROW AS MERGED — option B of [central-ticketing] #938.
+     *
+     * The rows the merge bug minted carry `merged_into_id` while their status
+     * says `open`. #920 left them editable ON PURPOSE, so that they could be
+     * corrected in the product; this is the correction, and until it existed the
+     * only way to make one was to type the right status into the Edit form and
+     * know that `merged` was not in the list.
+     *
+     * Note what it is NOT: it is not `update()` with a status of `merged`, which
+     * `refuseIfMerged()` would have to be weakened to allow, and it does not
+     * touch messages, participants or any field somebody edited after the merge.
+     * It writes one column, on a row that is provably in the broken shape, and
+     * it is a no-op on anything else — so a double-click, a stale page and a row
+     * a colleague fixed thirty seconds ago all land somewhere harmless.
+     */
+    public function markMerged(Ticket $ticket)
+    {
+        if (! $this->isAgent($ticket->group_id)) {
+            abort(403);
+        }
+
+        if (! $ticket->isInconsistentlyMerged()) {
+            // Deliberately not an error: the button is only rendered on a row in
+            // the broken shape, so arriving here means somebody else has already
+            // fixed it, and being told so is the right answer.
+            //
+            // #1567 gave `merged_inconsistent` a second shape, and "already
+            // consistent" would be a lie on one of them: a stranded row is still
+            // flagged, and what it needs is `unmerge()`, not this.
+            return redirect()->route('ticketing.show', $ticket)
+                ->with('success', $ticket->isStrandedMerge()
+                    ? 'That ticket is merged into a ticket that no longer exists — un-merge it instead.'
+                    : 'That ticket is already consistent — nothing to fix.');
+        }
+
+        MergedTicketRepair::repair($ticket, 'user '.Auth::id());
+
+        return redirect()->route('ticketing.show', $ticket)
+            ->with('success', "Ticket {$ticket->number} is marked merged and is read-only again.");
+    }
+
     /**
      * Split this ticket — create a copy with a new number, same metadata, duplicated messages.
      */
@@ -602,6 +951,10 @@ class TicketController extends Controller
             abort(403);
         }
 
+        if ($refusal = $this->refuseIfMerged($ticket)) {
+            return $refusal;
+        }
+
         $newTicket = DB::transaction(function () use ($ticket) {
             $group  = TicketingGroup::findOrFail($ticket->group_id);
             $number = $group->nextTicketNumber();
@@ -612,16 +965,31 @@ class TicketController extends Controller
                 'submitter_id' => $ticket->submitter_id,
                 'assigned_to' => $ticket->assigned_to,
                 'project_id'  => $ticket->project_id,
-                'title'       => $ticket->title . ' (split)',
+                'title'       => static::splitTitle($ticket->title),
                 'description' => $ticket->description,
                 'status'      => 'open',
                 'priority_id' => $ticket->priority_id,
                 'due_date'    => $ticket->due_date,
             ]);
 
-            // Duplicate messages (exclude system notes)
+            /*
+             * Duplicate messages, EXCLUDING system notes.
+             *
+             * This comment has always said "exclude" and the code never did. It cost
+             * nothing while the enum rejected 'system', because no system row could
+             * exist to copy — #415 makes them writable, so without this a split of a
+             * previously-merged ticket would carry "Merged from ticket QAX-0005." into
+             * a brand-new ticket that was never merged with anything.
+             *
+             * A system note is an audit record of something that happened to THIS
+             * ticket. The copy gets its own, written below.
+             */
             $ticket->load('messages');
             foreach ($ticket->messages as $msg) {
+                if ($msg->isSystem()) {
+                    continue;
+                }
+
                 TicketMessage::create([
                     'ticket_id'        => $newTicket->id,
                     'user_id'          => $msg->user_id,
@@ -633,20 +1001,8 @@ class TicketController extends Controller
             }
 
             // Cross-reference notes on both tickets
-            TicketMessage::create([
-                'ticket_id'   => $ticket->id,
-                'user_id'     => Auth::id(),
-                'body'        => "Split: new ticket {$newTicket->number} created from this ticket.",
-                'is_internal' => true,
-                'source'      => 'system',
-            ]);
-            TicketMessage::create([
-                'ticket_id'   => $newTicket->id,
-                'user_id'     => Auth::id(),
-                'body'        => "Split from ticket {$ticket->number}.",
-                'is_internal' => true,
-                'source'      => 'system',
-            ]);
+            TicketMessage::system($ticket, "Split: new ticket {$newTicket->number} created from this ticket.");
+            TicketMessage::system($newTicket, "Split from ticket {$ticket->number}.");
 
             return $newTicket;
         });
@@ -655,6 +1011,39 @@ class TicketController extends Controller
             ->with('success', "Ticket {$newTicket->number} created from split.");
     }
 
+    /**
+     * The split ticket's title: the original plus a suffix, guaranteed to fit.
+     *
+     * `tickets.title` is varchar(255) and both store() and update() validate the
+     * title at `max:255`. Appending " (split)" to a title already at the limit
+     * produced 263 characters and the same hard 500 as #415 — a second, unreported
+     * instance of it on the very action being fixed, needing only a long enough
+     * title to trigger.
+     *
+     * ── WHY THIS IS BOUNDED AND NOT WIDENED ─────────────────────────────────
+     *
+     * The sibling defect in central-radius (#410) was fixed the other way: a
+     * 510-character skip reason was widened into the column rather than shortened,
+     * because the reason was the point and the column was simply too small.
+     *
+     * The rule that separates them is what the limit MEANS. 255 here is not an
+     * incidental column width — it is the product's own declared, user-facing title
+     * limit, enforced by two validation rules. Widening the column to fit 263 would
+     * mint rows the edit form then refuses to save, so the ticket could never be
+     * corrected by anyone: a row the product will not let you fix is worse than a
+     * truncated title. So: widen when the data is right and the column is wrong;
+     * bound when the column expresses a real product rule.
+     *
+     * Multibyte-safe by character, because varchar(255) counts characters.
+     */
+    private static function splitTitle(string $title): string
+    {
+        $suffix = ' (split)';
+        $room   = 255 - mb_strlen($suffix);
+
+        return (mb_strlen($title) > $room ? mb_substr($title, 0, $room) : $title).$suffix;
+    }
+
     /**
      * Add a participant to a ticket.
      */
@@ -664,6 +1053,10 @@ class TicketController extends Controller
             abort(403);
         }
 
+        if ($refusal = $this->refuseIfMerged($ticket, stayPut: true)) {
+            return $refusal;
+        }
+
         $validated = $request->validate([
             'user_id' => 'required|integer|exists:users,id',
         ]);
@@ -685,9 +1078,21 @@ class TicketController extends Controller
             abort(403);
         }
 
+        if ($refusal = $this->refuseIfMerged($ticket, stayPut: true)) {
+            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.');
     }
@@ -696,6 +1101,66 @@ class TicketController extends Controller
      * Search users by name/email — for the participant picker.
      * Returns up to 10 matches, excluding existing participants and the submitter.
      */
+    /**
+     * WHO TO ADD AS A PARTICIPANT — and it answers in CHIPS (#1598).
+     *
+     * The operator, 11:46 PDT 2026-09-10, having just had the device picker
+     * converted: *"are there other places we can search users where we're not
+     * using the chips? please go through and check."* This endpoint was one of
+     * the six the lead's audit found that were not, and it is central-ticketing's.
+     *
+     * It returned `DB::table('users')->get(['id', 'name', 'email'])`, so the
+     * picker drew a name and an address per row and nothing else: no role dot to
+     * tell an agent that "D. Ellis" is the child rather than the parent of the
+     * same surname, and — because those two fields were once the WHOLE of a chip
+     * — a school that configures the student chip to grade + homeroom would have
+     * been left with this one picker still showing an address.
+     *
+     * `PersonChip::rows()` is the shared serializer and this is now the same
+     * answer, key for key, as `admin.settings.users.search` — which is the point
+     * rather than a coincidence: `TicketParticipantsAreChipsTest` compares the
+     * two payloads against each other instead of against a literal list, so a
+     * key added to the platform's row cannot skip this surface.
+     *
+     * WHO IS SEARCHABLE DOES NOT CHANGE. Same `like` on name-or-email, same
+     * two-character floor, same limit of 10, same exclusion of the people
+     * already on the ticket, and `User` carries no global scope or soft delete
+     * that `DB::table('users')` did not — measured against the model on
+     * 2026-09-10. The card was explicit that this one is about the DRAWING.
+     *
+     * Two things about the query are not cosmetic:
+     *
+     *  - `PersonChip::columns()` and not `['id', 'name', 'email']`. A chip line
+     *    may name any user column, and a constrained select hands the helper a
+     *    model whose attribute is simply ABSENT — indistinguishable from a
+     *    person who has no value, so the line is blank for everybody with
+     *    nothing failing. `PersonChip::columns()`' own docblock has the trap;
+     *    `PersonChipSurfacesTest::test_a_chip_is_never_built_from_a_hand_written_select`
+     *    is the shell's guard against it.
+     *  - The name-or-email `like` stays inside its own closure. Flattened beside
+     *    the exclusion it would be an `OR` at the top level and an address match
+     *    would smuggle a person already on the ticket back into the list — the
+     *    operator-precedence hole the same shape opened on [central-inventory]
+     *    #1594.
+     *
+     * AN ORDER AT ALL is new, and it is `PersonNames::orderUsers()` rather than
+     * `orderBy('name')`. The old query had no order, so ten rows arrived in
+     * whatever sequence the storage engine happened to return them and the same
+     * two letters could list the same people differently twice running. But the
+     * 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)
     {
         if (! $this->isAgent($ticket->group_id)) {
@@ -713,16 +1178,16 @@ class TicketController extends Controller
             ->unique()
             ->values();
 
-        $users = DB::table('users')
-            ->where(function ($query) use ($q) {
+        return response()->json(PersonChip::rows(
+            User::where(function ($query) use ($q) {
                 $query->where('name', 'like', "%{$q}%")
                       ->orWhere('email', 'like', "%{$q}%");
             })
-            ->whereNotIn('id', $excludeIds)
-            ->limit(10)
-            ->get(['id', 'name', 'email']);
-
-        return response()->json($users);
+                ->whereNotIn('id', $excludeIds)
+                ->tap(fn ($query) => PersonNames::orderUsers($query))
+                ->limit(10)
+                ->get(PersonChip::columns())
+        ));
     }
 
     public function myTickets(): Response

src/Http/Controllers/TicketMessageController.php

@@ -29,6 +29,19 @@ class TicketMessageController extends Controller
             abort(403);
         }
 
+        /*
+         * A merged ticket takes no new messages — [central-ticketing] #920.
+         *
+         * Show.vue replaces the composer with "This ticket has been merged and is
+         * read-only.", and that was the whole of the guard: a POST straight to this
+         * route (or from a page that was already open when the merge happened) still
+         * wrote a message onto a ticket whose thread has moved to the merge target,
+         * where nobody working the ticket would ever see it.
+         */
+        if ($ticket->isMerged()) {
+            return back()->withErrors(['ticket' => Ticket::READ_ONLY_REASON]);
+        }
+
         $validated = $request->validate([
             'body' => 'required|string',
             'is_internal' => 'boolean',
@@ -62,9 +75,37 @@ class TicketMessageController extends Controller
         return back()->with('success', 'Message sent.');
     }
 
+    /**
+     * Issue #8: this was an empty placeholder, so nobody has ever been told their
+     * ticket was answered. Goes through the Notifications platform so it lands in the
+     * shared Notification Log and honours the person's preferences, rather than
+     * reaching for Mail:: directly as the old comment suggested.
+     *
+     * Only ever called for a non-internal agent reply — see the caller.
+     */
     private function notifySubmitter(Ticket $ticket, TicketMessage $message): void
     {
-        // Placeholder for email notification
-        // In production: Mail::to($submitterEmail)->send(new TicketReplyMail($ticket, $message));
+        $submitter = \App\Models\User::find($ticket->submitter_id);
+
+        if (! $submitter) {
+            return;     // a ticket raised on behalf of somebody with no account
+        }
+
+        $url = route('ticketing.show', $ticket->id);
+        $author = $message->user_id ? (\App\Models\User::find($message->user_id)?->name ?? 'An agent') : 'An agent';
+
+        // The submitter, not their address. Handing Notify a string dropped
+        // to_user_id and to_name (so the Log printed the message type where the
+        // name goes) and skipped the preference check entirely, so the opt-out for
+        // this category did nothing. Notify resolves the address itself.
+        \Dashboard\Ticketing\Support\TicketingNotifier::deliver(
+            \Dashboard\Ticketing\Support\TicketingNotifier::REPLIED,
+            $submitter,
+            "[{$ticket->number}] {$ticket->title}",
+            '<p>'.e($author).' replied to your ticket:</p>'
+                .'<blockquote>'.nl2br(e($message->body)).'</blockquote>'
+                .'<p><a href="'.e($url).'">View the ticket</a></p>',
+            $ticket,
+        );
     }
 }

src/Http/Controllers/TicketingSettingsController.php

@@ -3,12 +3,16 @@
 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\MergedTicketRepair;
 use Illuminate\Http\Request;
 use Illuminate\Routing\Controller;
 use Illuminate\Support\Facades\Auth;
@@ -30,8 +34,21 @@ class TicketingSettingsController extends Controller
      */
     private function isSiteAdmin(): bool
     {
-        $user = Auth::user();
-        return $user && ($user->is_super_admin || $user->can('ticketing.settings'));
+        return $this->isSiteAdminUser(Auth::user());
+    }
+
+    /**
+     * 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'));
     }
 
     /**
@@ -53,15 +70,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
@@ -70,15 +247,51 @@ 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)->get();
+            : 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')
+                ->orderByRaw('archived_at IS NOT NULL')
+                ->orderBy('name')
+                ->get();
 
         $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();
@@ -86,19 +299,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,
@@ -109,9 +371,24 @@ 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
+            // actually make, so it is shown beside it whether the toggle is on or off.
+            'autoRepairMerged' => MergedTicketRepair::enabledOnDeploy(),
+            'inconsistentMergedCount' => MergedTicketRepair::count(),
         ]);
     }
 
@@ -180,35 +457,327 @@ class TicketingSettingsController extends Controller
         return back()->with('success', 'Group updated.');
     }
 
+    /**
+     * Retire a group — hard delete when it is empty, archive when it is not.
+     *
+     * Tickets are the audit record of real correspondence, so a group that owns
+     * any ticket can never be deleted: `tickets.group_id` is a RESTRICT foreign
+     * key, which is the backstop, and this method is the polite front door. It
+     * archives instead, leaving every ticket byte-identical and readable.
+     *
+     * An empty group has nothing to protect, so it really is deleted — which is
+     * what lets an operator undo a typo and lets the e2e CRUD spec clean up the
+     * throwaway group it creates as its setup step (issue #7).
+     *
+     * The caller is told which of the two happened, explicitly: an `outcome` of
+     * `deleted` or `archived` in the JSON body for API callers, and distinct
+     * flash wording for the Inertia UI. Nobody has to guess from a 302.
+     */
+    public function destroyGroup(Request $request, TicketingGroup $group)
+    {
+        $this->requireManagerAccess($group->id);
+
+        $ticketCount = $group->tickets()->count();
+
+        if ($ticketCount > 0) {
+            // Idempotent: archiving an already-archived group is not an error,
+            // it just re-reports the same outcome.
+            if ($group->archived_at === null) {
+                $group->archived_at = now();
+                $group->save();
+            }
+
+            return $this->groupRetirementResponse($request, 'archived', $group, $ticketCount);
+        }
+
+        // Empty group: agent access, projects and email connections all cascade
+        // on delete (see their migrations), so nothing is left dangling.
+        $group->delete();
+
+        return $this->groupRetirementResponse($request, 'deleted', $group, 0);
+    }
+
+    /**
+     * Un-archive a group so it can take new tickets again.
+     */
+    public function restoreGroup(Request $request, TicketingGroup $group)
+    {
+        $this->requireManagerAccess($group->id);
+
+        if ($group->archived_at !== null) {
+            $group->archived_at = null;
+            $group->save();
+        }
+
+        if ($this->wantsJsonBody($request)) {
+            return response()->json([
+                'outcome'  => 'restored',
+                'group_id' => $group->id,
+            ]);
+        }
+
+        return back()->with('success', "Group “{$group->name}” restored.");
+    }
+
+    /**
+     * One shape for "what happened to that group", for both kinds of caller.
+     */
+    private function groupRetirementResponse(Request $request, string $outcome, TicketingGroup $group, int $ticketCount)
+    {
+        if ($this->wantsJsonBody($request)) {
+            return response()->json([
+                'outcome'      => $outcome,
+                'group_id'     => $group->id,
+                'ticket_count' => $ticketCount,
+            ]);
+        }
+
+        $message = $outcome === 'deleted'
+            ? "Group “{$group->name}” deleted — it had no tickets."
+            : "Group “{$group->name}” archived — it has {$ticketCount} ticket"
+                . ($ticketCount === 1 ? '' : 's') . ', which stay readable.';
+
+        return back()->with('success', $message);
+    }
+
+    /**
+     * True for an API/script caller that wants a JSON body.
+     *
+     * Inertia sends `Accept: text/html` but also XHR headers, so
+     * expectsJson() alone would hijack the UI's redirect-back flow.
+     */
+    private function wantsJsonBody(Request $request): bool
+    {
+        if ($request->header('X-Inertia')) {
+            return false;
+        }
+
+        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();
 
         $validated = $request->validate([
-            'user_id' => 'required|exists:users,id',
-            'group_id' => 'required|exists:ticketing_groups,id',
+            'user_id' => 'required|integer|exists:users,id',
+            // `integer` before `exists`: an array value passes `exists` element-wise,
+            // so [14] would reach the code below as an array. See TicketController::store().
+            'group_id' => 'required|integer|exists:ticketing_groups,id',
             '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()) {
@@ -219,7 +788,10 @@ class TicketingSettingsController extends Controller
             'name'        => 'required|string|max:100',
             'color'       => 'required|string|regex:/^#[0-9a-fA-F]{6}$/',
             'description' => 'nullable|string',
-            'sort_order'  => 'integer|min:0',
+            // unsignedSmallInteger column (0..65535): without the ceiling an
+            // oversized client value overflows on INSERT as an unhandled 500.
+            // Same rule #6081 put on storeStatus()/updateStatus().
+            'sort_order'  => 'integer|min:0|max:65535',
         ]);
 
         PriorityLevel::create($validated);
@@ -237,7 +809,7 @@ class TicketingSettingsController extends Controller
             'name'        => 'required|string|max:100',
             'color'       => 'required|string|regex:/^#[0-9a-fA-F]{6}$/',
             'description' => 'nullable|string',
-            'sort_order'  => 'required|integer|min:0',
+            'sort_order'  => 'required|integer|min:0|max:65535',
         ]);
 
         $priority->update($validated);
@@ -267,7 +839,9 @@ class TicketingSettingsController extends Controller
         $this->requireAgentAccess();
 
         $validated = $request->validate([
-            'group_id' => 'required|exists:ticketing_groups,id',
+            // `integer` before `exists`: an array value passes `exists` element-wise,
+            // so [14] would reach the code below as an array. See TicketController::store().
+            'group_id' => 'required|integer|exists:ticketing_groups,id',
             'name' => 'required|string|max:100',
             'description' => 'nullable|string',
             'status' => 'required|in:active,archived',
@@ -320,7 +894,9 @@ class TicketingSettingsController extends Controller
         $this->requireAgentAccess();
 
         $validated = $request->validate([
-            'group_id' => 'required|exists:ticketing_groups,id',
+            // `integer` before `exists`: an array value passes `exists` element-wise,
+            // so [14] would reach the code below as an array. See TicketController::store().
+            'group_id' => 'required|integer|exists:ticketing_groups,id',
             'type' => 'required|in:gmail,imap',
             'active' => 'boolean',
             'config.host' => 'nullable|string|max:255',
@@ -362,12 +938,43 @@ class TicketingSettingsController extends Controller
         $connection->update([
             'type' => $request->type,
             'active' => $request->boolean('active', true),
-            'config' => $request->input('config', $connection->config),
+            'config' => $this->mergedConnectionConfig($request, $connection),
         ]);
 
         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();
@@ -385,7 +992,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',
         ]);
 
@@ -416,7 +1023,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',
         ]);
 
@@ -462,10 +1069,20 @@ class TicketingSettingsController extends Controller
 
         $validated = $request->validate([
             'auto_close_days' => 'required|integer|min:0|max:365',
+            'auto_repair_merged_on_deploy' => 'sometimes|boolean',
         ]);
 
         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
+        // off: a deploy must never rewrite rows nobody asked it to rewrite.
+        if (array_key_exists('auto_repair_merged_on_deploy', $validated)) {
+            Setting::set(
+                MergedTicketRepair::SETTING,
+                $validated['auto_repair_merged_on_deploy'] ? '1' : '0',
+            );
+        }
+
         return back()->with('success', 'Automation settings saved.');
     }
 }

src/Models/Ticket.php

@@ -2,19 +2,77 @@
 
 namespace Dashboard\Ticketing\Models;
 
+use Illuminate\Database\Eloquent\Builder;
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Database\Eloquent\Relations\BelongsTo;
 use Illuminate\Database\Eloquent\Relations\HasMany;
 
 class Ticket extends Model
 {
+    /** Set only by TicketController::merge(); never offered by any form. */
+    public const STATUS_MERGED = 'merged';
+
+    /**
+     * WHERE AN UN-MERGED TICKET LANDS — [central-ticketing] #1567.
+     *
+     * A merge is a way of closing a ticket, so a ticket that is un-merged because
+     * its target was deleted goes to `closed` and not to `open`: it stays out of
+     * the All Open / Mine / Unassigned work queues, exactly as it was before, and
+     * the only thing that changes is that it is no longer read-only, so an agent
+     * can reopen it, reply to it or reassign it. Un-merging to `open` would push
+     * somebody's tidied-away ticket back into a live queue without being asked.
+     *
+     * It is one of the six values the `tickets.status` ENUM allows and it is
+     * `is_closed` in `ticketing_statuses`, so both the column and every count
+     * that reads `$closedSlugs` already understand it.
+     */
+    public const STATUS_UNMERGED = 'closed';
+
+    /**
+     * What every surface says when a write to a merged ticket is refused. The Show
+     * page has displayed this sentence since merge shipped; #920 was that it was
+     * only ever a sentence, with no server-side guard behind it.
+     */
+    public const READ_ONLY_REASON = 'This ticket has been merged and is read-only.';
+
     protected $fillable = [
         'number', 'group_id', 'submitter_id', 'assigned_to', 'project_id',
         'title', 'description', 'status', 'priority_id', 'due_date', 'merged_into_id',
     ];
 
+    // `date:Y-m-d`, not bare `date`. The column is a DATE and every UI that shows
+    // it is an <input type="date">, which accepts exactly `Y-m-d` and silently
+    // renders anything else as an EMPTY field. A bare `date` cast serializes to
+    // `2026-09-15T00:00:00.000000Z`, so a due date that had been stored perfectly
+    // well came back as a blank input on the edit form, the show page and the
+    // index pane — indistinguishable from "it was never saved", which is how this
+    // was reported (a QA sweep read `input.value === ''` as silent data loss).
+    //
+    // The write path was never at fault: the column, the `$fillable` entry and
+    // both `validate()` rules were correct throughout, and re-submitting the ISO
+    // string (which Show.vue's meta form does, because it seeds itself from this
+    // value) still stores the right day — measured in UTC and in
+    // America/New_York. So nothing was ever lost in the database; the value
+    // simply had no way of reaching the screen.
+    /**
+     * `merged_inconsistent` rides on every serialized ticket — #938.
+     *
+     * The badge and its "Mark merged" button are rendered per ROW, on the index
+     * list, in the detail pane and on the Show header, so the page needs the
+     * answer for each ticket it draws. Handing it the model's own predicate
+     * rather than letting three Vue files each write
+     * `t.merged_into_id && t.status !== 'merged'` is what keeps the client's idea
+     * of "inconsistent" from drifting away from the scope the repair uses.
+     * It costs no query — both columns are already loaded.
+     *
+     * #1567 added `merged_stranded` beside it, for the same reason: there are now
+     * TWO ways a merge can fail to add up and they need different offers, so the
+     * page is handed which one it is rather than working it out from the columns.
+     */
+    protected $appends = ['merged_inconsistent', 'merged_stranded'];
+
     protected $casts = [
-        'due_date' => 'date',
+        'due_date' => 'date:Y-m-d',
     ];
 
     public function group(): BelongsTo
@@ -56,4 +114,138 @@ class Ticket extends Model
     {
         return $this->belongsTo(Ticket::class, 'merged_into_id');
     }
+
+    /**
+     * A merged ticket is read-only — its messages and attachments now live on the
+     * ticket it was merged into, so it is a stub kept for its reference number and
+     * the audit trail, not a ticket anyone can still work.
+     *
+     * `status === 'merged'` and NOT `merged_into_id !== null`, deliberately. #920
+     * minted rows with `status = 'open', merged_into_id = 56` — the very rows this
+     * guard exists to prevent — and reading the id would make each of those
+     * permanently uneditable, i.e. a row the product will not let anyone correct.
+     * The status is the state; the id is the pointer that goes with it.
+     */
+    public function isMerged(): bool
+    {
+        return $this->status === self::STATUS_MERGED;
+    }
+
+    /**
+     * THE SHAPE THE MERGE BUG MINTED — [central-ticketing] #938.
+     *
+     * `merged_into_id` points at a target while `status` is something other than
+     * `merged`: the row was merged, and then a save through the unguarded Edit
+     * form (#920) put the status back. #920 stopped new ones being made and
+     * deliberately left the existing ones EDITABLE — `isMerged()` reads the
+     * status, not the pointer — so that the office can correct one rather than
+     * needing SQL. This is the predicate that finds them.
+     *
+     * It is one definition and three callers read it: the badge that offers the
+     * fix, the `mark-merged` verb that applies it one row at a time, and the
+     * repair migration that applies it to all of them at once. Two spellings of
+     * "inconsistent" that drifted apart would mean a badge on a row the repair
+     * skips.
+     */
+    public function scopeInconsistentlyMerged(Builder $query): Builder
+    {
+        return $query->whereNotNull('merged_into_id')
+            ->where('status', '!=', self::STATUS_MERGED);
+    }
+
+    /** The row-level twin of {@see scopeInconsistentlyMerged()}. */
+    public function isInconsistentlyMerged(): bool
+    {
+        return $this->merged_into_id !== null && ! $this->isMerged();
+    }
+
+    /**
+     * THE OTHER DIRECTION — [central-ticketing] #1567.
+     *
+     * `status = 'merged'` with NOTHING to point at. `merged_into_id` carries
+     * `nullOnDelete()`, so deleting the ticket that others had been merged INTO
+     * used to blank their pointer and leave the status behind: a row that
+     * {@see isMerged()} still calls read-only, whose banner names a ticket that
+     * no longer exists, and which the Merged view — scoped by the pointer — could
+     * not list. Nothing in the product could act on it.
+     *
+     * `destroy()` no longer mints these ({@see \Dashboard\Ticketing\Support\StrandedMerge}),
+     * but the rows already made are still out there, so the shape needs a name:
+     * this is what the badge offers to un-merge and what the Merged view now
+     * includes.
+     *
+     * Deliberately NOT folded into {@see scopeInconsistentlyMerged()}: that scope
+     * is what #938's repair writes `status = 'merged'` over, and a stranded row
+     * already HAS that status — repairing it would match forever and write
+     * nothing, which is exactly the idempotency the repair guarantees.
+     */
+    public function scopeStrandedMerge(Builder $query): Builder
+    {
+        return $query->where('status', self::STATUS_MERGED)
+            ->whereNull('merged_into_id');
+    }
+
+    /** The row-level twin of {@see scopeStrandedMerge()}. */
+    public function isStrandedMerge(): bool
+    {
+        return $this->isMerged() && $this->merged_into_id === null;
+    }
+
+    /**
+     * EITHER shape of a merge that does not add up — #938's and #1567's.
+     *
+     * The two are mutually exclusive by construction (one has a pointer and the
+     * wrong status, the other has the right status and no pointer), and the
+     * badge, the sidebar's warning count and `merged_inconsistent` all want the
+     * union: "this row's status and its pointer disagree, whichever way round".
+     * The repair scopes stay separate because the fixes differ.
+     */
+    public function scopeMergeInconsistent(Builder $query): Builder
+    {
+        return $query->where(function (Builder $q) {
+            $q->where(fn (Builder $i) => $i->inconsistentlyMerged())
+                ->orWhere(fn (Builder $s) => $s->strandedMerge());
+        });
+    }
+
+    /**
+     * Every row that carries the merge shape AT ALL — what the Merged view lists.
+     *
+     * Pointer set (whatever the status: #938's rows included) or status `merged`
+     * (whether or not the pointer survived: #1567's stranded rows included).
+     * Scoping the view by the pointer alone dropped a stranded row out of the one
+     * view whose whole job is showing merges, leaving it visible only under
+     * Resolved — so a reader looking for merged tickets never found it.
+     */
+    public function scopeEverMerged(Builder $query): Builder
+    {
+        return $query->where(function (Builder $q) {
+            $q->whereNotNull('merged_into_id')
+                ->orWhere('status', self::STATUS_MERGED);
+        });
+    }
+
+    /**
+     * @see $appends — the same answer, for the page.
+     *
+     * #1567 widened this to the union: a stranded row is inconsistent in the
+     * plainest sense (it says it is merged into nothing), and the flag existing
+     * while reading `false` on exactly that row was half of what the card
+     * reported.
+     */
+    public function getMergedInconsistentAttribute(): bool
+    {
+        return $this->isInconsistentlyMerged() || $this->isStrandedMerge();
+    }
+
+    /**
+     * @see $appends — WHICH of the two shapes, for a page that must offer
+     * different fixes. `merged_inconsistent` says something is wrong;
+     * `merged_stranded` says the target is gone, so the offer is "un-merge"
+     * rather than #938's "mark merged".
+     */
+    public function getMergedStrandedAttribute(): bool
+    {
+        return $this->isStrandedMerge();
+    }
 }

src/Models/TicketMessage.php

@@ -5,9 +5,20 @@ namespace Dashboard\Ticketing\Models;
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Database\Eloquent\Relations\BelongsTo;
 use Illuminate\Database\Eloquent\Relations\HasMany;
+use Illuminate\Support\Facades\Auth;
 
 class TicketMessage extends Model
 {
+    /**
+     * Every value `ticket_messages.source` accepts, written down once.
+     *
+     * The column is an enum and this is the same list, so the two can be compared
+     * rather than remembered. #415 was three `'source' => 'system'` literals against
+     * a column that only knew 'web' and 'email' — the value existed in the code for
+     * as long as merge and split have, and nowhere in the schema.
+     */
+    public const SOURCES = ['web', 'email', 'system'];
+
     protected $fillable = [
         'ticket_id', 'user_id', 'author_email', 'body',
         'is_internal', 'source', 'email_message_id',
@@ -17,6 +28,33 @@ class TicketMessage extends Model
         'is_internal' => 'boolean',
     ];
 
+    /**
+     * THE ONLY WAY A SYSTEM NOTE IS WRITTEN.
+     *
+     * Merge writes one and split writes two, and before this they were three
+     * separate literals in one controller — which is how all three carried a
+     * `source` the column rejected, and how a fourth would have joined them.
+     *
+     * A system note is always internal: it is the audit trail of an agent action,
+     * addressed to whoever works the ticket next, and never to the submitter.
+     */
+    public static function system(Ticket|int $ticket, string $body): self
+    {
+        return static::create([
+            'ticket_id'   => $ticket instanceof Ticket ? $ticket->id : $ticket,
+            'user_id'     => Auth::id(),
+            'body'        => $body,
+            'is_internal' => true,
+            'source'      => 'system',
+        ]);
+    }
+
+    /** A note this class wrote, rather than a person or a mailbox. */
+    public function isSystem(): bool
+    {
+        return $this->source === 'system';
+    }
+
     public function ticket(): BelongsTo
     {
         return $this->belongsTo(Ticket::class, 'ticket_id');

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/Models/TicketingGroup.php

@@ -2,13 +2,45 @@
 
 namespace Dashboard\Ticketing\Models;
 
+use Illuminate\Database\Eloquent\Builder;
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Database\Eloquent\Relations\HasMany;
+use Illuminate\Support\Facades\DB;
 
 class TicketingGroup extends Model
 {
     protected $fillable = ['name', 'email_address', 'color', 'prefix'];
 
+    protected $casts = [
+        'archived_at' => 'datetime',
+    ];
+
+    protected $appends = ['is_archived'];
+
+    /**
+     * Archived groups are deliberately NOT hidden by a global scope.
+     *
+     * The tickets in an archived group are still live correspondence: their
+     * agents must keep working them, `$ticket->group` must still resolve, and
+     * Settings must still list the group so a manager can restore it. Only the
+     * *pickers* — "which group should this new ticket go to", "filter by
+     * group" — exclude archived ones, via this scope, one call site at a time.
+     */
+    public function scopeActive(Builder $query): Builder
+    {
+        return $query->whereNull('archived_at');
+    }
+
+    public function scopeArchived(Builder $query): Builder
+    {
+        return $query->whereNotNull('archived_at');
+    }
+
+    public function getIsArchivedAttribute(): bool
+    {
+        return $this->archived_at !== null;
+    }
+
     public function tickets(): HasMany
     {
         return $this->hasMany(Ticket::class, 'group_id');
@@ -34,15 +66,59 @@ class TicketingGroup extends Model
         return $this->hasMany(EmailConnection::class, 'group_id');
     }
 
+    /**
+     * Issue the next ticket reference for this group.
+     *
+     * This used to be MAX(suffix) over the group's live tickets. Tickets are
+     * hard-deleted, so that made the reference a *reusable* handle: delete the
+     * newest ticket and its number went back in the pool, and the next ticket was
+     * issued the same one. Two tickets carrying `QAX-0004` is not a cosmetic
+     * problem — the reference is the `[QAX-0004]` token in outbound mail subjects
+     * (so a reply threads onto the wrong ticket), the key the shell Notification
+     * Log is audited by, and what `merge()` resolves a ticket by.
+     *
+     * The number now comes from `last_ticket_number`, a per-group high-water mark
+     * that is only ever raised. Deleting a ticket cannot lower it, because it does
+     * not consult the tickets table for the answer.
+     *
+     * Two details that are not decoration:
+     *
+     * - `lockForUpdate` inside a transaction. Read-then-write is a race: two people
+     *   submitting at the same instant would otherwise both read N and both be
+     *   issued N+1, reintroducing exactly the duplicate this method exists to
+     *   prevent. The row lock serialises them.
+     * - The counter is raised to clear any live ticket that is already numbered
+     *   past it before being incremented. Not every row gets its number from here —
+     *   `TicketingDemoSeeder` writes them directly, and imports and manual repairs
+     *   can too — and a counter that has fallen behind such a row would issue a
+     *   number that is already in use. Taking the max of the two can only ever move
+     *   the counter forwards, so this preserves the never-goes-backwards property
+     *   rather than weakening it.
+     */
     public function nextTicketNumber(): string
     {
         $prefix = $this->prefix . '-';
-        $last = $this->tickets()
-            ->where('number', 'like', $prefix . '%')
-            ->orderByRaw('CAST(SUBSTRING(number, ?) AS UNSIGNED) DESC', [strlen($prefix) + 1])
-            ->value('number');
 
-        $next = $last ? ((int) substr($last, strlen($prefix))) + 1 : 1;
+        $next = DB::transaction(function () use ($prefix) {
+            $counter = (int) static::query()
+                ->whereKey($this->getKey())
+                ->lockForUpdate()
+                ->value('last_ticket_number');
+
+            $liveMax = (int) $this->tickets()
+                ->where('number', 'like', $prefix . '%')
+                ->max(DB::raw('CAST(SUBSTRING(number, ' . (strlen($prefix) + 1) . ') AS UNSIGNED)'));
+
+            $next = max($counter, $liveMax) + 1;
+
+            // Query-builder update, so `last_ticket_number` need not be fillable —
+            // it is a sequence, never something a form should be able to set.
+            static::query()->whereKey($this->getKey())->update(['last_ticket_number' => $next]);
+            $this->setAttribute('last_ticket_number', $next);
+
+            return $next;
+        });
+
         return $prefix . str_pad($next, 4, '0', STR_PAD_LEFT);
     }
 }

src/Support/MergedTicketRepair.php

@@ -0,0 +1,138 @@
+<?php
+
+namespace Dashboard\Ticketing\Support;
+
+use App\Models\Setting;
+use Dashboard\Ticketing\Models\Ticket;
+use Illuminate\Support\Facades\Log;
+
+/**
+ * REPAIRING THE ROWS THE MERGE BUG MINTED — [central-ticketing] #938.
+ *
+ * #920 stopped the bug making new ones: a ticket whose `status` is `merged` is
+ * read-only server-side, so the Edit form can no longer write `status = open`
+ * over a row that has already been folded into another ticket. It shipped NO
+ * data change, on purpose, and its guard reads the status rather than the
+ * pointer precisely so the rows already carrying the corrupt shape
+ * (`status = open, merged_into_id = 56`) stay editable and can be corrected
+ * through the UI instead of by hand in SQL.
+ *
+ * This class is the correction, and it is deliberately ONE implementation with
+ * three callers, because "which rows are broken" and "what fixing one means"
+ * are the two things that must not drift:
+ *
+ *   - {@see \Dashboard\Ticketing\Http\Controllers\TicketController::markMerged()}
+ *     — the office fixes one row, from the badge on the ticket header.
+ *   - {@see \Dashboard\Ticketing\Console\Commands\RepairMergedTickets}
+ *     — `--dry-run` is the COUNT, and it is the whole reason the class is not
+ *     just a line inside the migration: the operator has to be able to see how
+ *     many rows there are, and which, before anything writes.
+ *   - the `2026_09_04_000001_repair_inconsistent_merged_tickets` migration
+ *     — every row at once, on deploy, and ONLY when the operator has turned
+ *     {@see SETTING} on.
+ *
+ * ── WHAT REPAIRING DOES *NOT* DO ────────────────────────────────────────────
+ *
+ * It writes `status = 'merged'` and nothing else. Messages, participants,
+ * assignee, priority and title are left exactly as they are, including edits
+ * made to the row AFTER the merge — those are somebody's work, they are the
+ * only copy, and there is no record of what the fields held before the bad
+ * save to revert them to. The ticket becoming read-only is the whole change.
+ */
+class MergedTicketRepair
+{
+    /**
+     * "Auto-repair inconsistent merged tickets on deploy", and it DEFAULTS OFF.
+     *
+     * A deploy that silently rewrites rows nobody asked it to rewrite is the one
+     * outcome #938 rules out by name, so the migration reads this and no-ops
+     * when it is unset. Off is therefore the whole behaviour of a box that has
+     * never heard of this setting, which is what makes shipping the migration
+     * safe before the operator has decided anything.
+     */
+    public const SETTING = 'ticketing.auto_repair_merged_on_deploy';
+
+    /** How many rows are inconsistent right now. The dry run, and it writes nothing. */
+    public static function count(): int
+    {
+        return Ticket::query()->inconsistentlyMerged()->count();
+    }
+
+    /**
+     * The rows themselves, for a human to look at before deciding.
+     *
+     * @return \Illuminate\Database\Eloquent\Collection<int,Ticket>
+     */
+    public static function rows()
+    {
+        return Ticket::query()->inconsistentlyMerged()->orderBy('id')->get();
+    }
+
+    /** Has the operator asked for the deploy-time repair? */
+    public static function enabledOnDeploy(): bool
+    {
+        return filter_var(Setting::get(self::SETTING, '0'), FILTER_VALIDATE_BOOLEAN);
+    }
+
+    /**
+     * Re-mark every inconsistent row as merged. Returns how many rows changed.
+     *
+     * IDEMPOTENT, and it is the scope that makes it so rather than a flag: the
+     * second run matches nothing, because the first run's rows no longer satisfy
+     * `status <> 'merged'`. So a migration that is re-run, a command run twice
+     * and a deploy that repeats all answer 0 and write nothing.
+     */
+    public static function repairAll(string $by): int
+    {
+        $tickets = Ticket::query()->inconsistentlyMerged()->orderBy('id')->get();
+
+        if ($tickets->isEmpty()) {
+            Log::info("[ticketing] #938 merged-ticket repair ({$by}): nothing to repair.");
+
+            return 0;
+        }
+
+        // Per model, not one builder update (#4781/#4807): `merged` makes a ticket
+        // 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.
+        Log::info(sprintf(
+            '[ticketing] #938 merged-ticket repair (%s): re-marked %d ticket(s) as merged — %s',
+            $by,
+            $changed,
+            implode(', ', $numbers),
+        ));
+
+        return $changed;
+    }
+
+    /**
+     * Re-mark ONE row. Returns false when it was not inconsistent to begin with,
+     * so a double-clicked button and a stale page are both no-ops rather than a
+     * second write.
+     */
+    public static function repair(Ticket $ticket, string $by): bool
+    {
+        if (! $ticket->isInconsistentlyMerged()) {
+            return false;
+        }
+
+        $ticket->forceFill(['status' => Ticket::STATUS_MERGED])->save();
+
+        Log::info(sprintf(
+            '[ticketing] #938 merged-ticket repair (%s): re-marked %s as merged (merged into #%d).',
+            $by,
+            $ticket->number,
+            $ticket->merged_into_id,
+        ));
+
+        return true;
+    }
+}

src/Support/StrandedMerge.php

@@ -0,0 +1,202 @@
+<?php
+
+namespace Dashboard\Ticketing\Support;
+
+use Dashboard\Ticketing\Models\Ticket;
+use Dashboard\Ticketing\Models\TicketMessage;
+use Illuminate\Support\Facades\Log;
+
+/**
+ * DELETING A MERGE TARGET MUST NOT STRAND WHAT WAS MERGED INTO IT — #1567.
+ *
+ * `tickets.merged_into_id` is declared `nullOnDelete()`, so deleting a ticket
+ * that other tickets had been merged INTO used to blank their pointer and walk
+ * away, leaving `status = 'merged'` behind with nothing on the other end:
+ *
+ *   - {@see Ticket::isMerged()} still calls the row read-only, so the page drops
+ *     the status / priority / assignee selects and the reply composer, and the
+ *     only control left on it is Delete. Nothing can reopen it, reassign it or
+ *     reply to it — ever.
+ *   - the banner "This ticket has been merged and is read-only." names a merge
+ *     target that no longer exists.
+ *   - the Merged view was scoped by the pointer, so the row vanished from the one
+ *     view whose job is showing merges and turned up only under Resolved.
+ *
+ * And `destroy()` gave no hint any of this was about to happen: the confirm was
+ * the generic "This cannot be undone."
+ *
+ * ── WHAT THIS DOES INSTEAD ──────────────────────────────────────────────────
+ *
+ * {@see handleTargetDeletion()} runs inside `destroy()`'s transaction, BEFORE the
+ * row goes, and gives every ticket pointing at it somewhere real to be:
+ *
+ *   RE-POINT, when the doomed ticket was itself merged into a third ticket. The
+ *   messages genuinely did travel that far — merge moves them to the target, so
+ *   merging the target onward moved them again — and the surviving ticket at the
+ *   end of the chain really is where this ticket's content lives. This is the
+ *   answer that keeps the merge true.
+ *
+ *   UN-MERGE, otherwise. There is nowhere left to point, so the row stops
+ *   claiming to be merged: {@see Ticket::STATUS_UNMERGED} (`closed`) and a NULL
+ *   pointer, which is an ordinary closed ticket — out of the work queues, but
+ *   editable, reopenable and answerable again.
+ *
+ * Either way the source gets a system note saying which ticket was deleted and
+ * what happened to it, because the row is being changed by somebody who was
+ * looking at a different ticket entirely and its own history is the only place
+ * that will ever explain it.
+ *
+ * ── THE ROWS ALREADY OUT THERE ──────────────────────────────────────────────
+ *
+ * This stops new ones. The stranded rows prod already holds are found by
+ * {@see Ticket::scopeStrandedMerge()}, now report `merged_inconsistent`, are
+ * listed by the Merged view, and are released one at a time by
+ * {@see \Dashboard\Ticketing\Http\Controllers\TicketController::unmerge()} —
+ * which calls {@see release()} here, so "un-merged" means one thing whichever
+ * door it came through.
+ *
+ * Deliberately NOT part of {@see MergedTicketRepair}: that class repairs #938's
+ * shape by writing `status = 'merged'` onto a row that has a target. This is the
+ * opposite operation on the opposite shape, and the two must not share a scope.
+ */
+class StrandedMerge
+{
+    /** How many rows are stranded right now — status `merged`, pointer NULL. */
+    public static function count(): int
+    {
+        return Ticket::query()->strandedMerge()->count();
+    }
+
+    /**
+     * The stranded rows themselves.
+     *
+     * @return \Illuminate\Database\Eloquent\Collection<int,Ticket>
+     */
+    public static function rows()
+    {
+        return Ticket::query()->strandedMerge()->orderBy('id')->get();
+    }
+
+    /**
+     * Give every ticket merged into `$target` somewhere real to be, before
+     * `$target` is deleted. Call inside the deleting transaction.
+     *
+     * Group membership is NOT re-checked per source. A source can live in another
+     * group, and the alternative to touching it is leaving it permanently frozen
+     * — this is the delete's own clean-up, not a write the operator chose to make
+     * on that ticket.
+     *
+     * @return array{repointed: list<string>, unmerged: list<string>, cleared: list<string>}
+     *         ticket numbers, by what happened to them
+     */
+    public static function handleTargetDeletion(Ticket $target, string $by): array
+    {
+        $sources = Ticket::where('merged_into_id', $target->id)->get();
+
+        $result = ['repointed' => [], 'unmerged' => [], 'cleared' => []];
+
+        if ($sources->isEmpty()) {
+            return $result;
+        }
+
+        // Where the content actually went. `merged_into_id` is nulled when ITS
+        // target is deleted, so this is either a live ticket or nothing.
+        $chain = $target->merged_into_id;
+
+        foreach ($sources as $source) {
+            // #938's shape: the pointer is stale but the status is live, so the
+            // row is an ordinary working ticket that happens to carry a dangling
+            // id. Dropping the id is the whole fix — and it is what the FK was
+            // about to do anyway; doing it here means the row is consistent
+            // inside this transaction rather than as a side effect afterwards.
+            if (! $source->isMerged()) {
+                $source->forceFill(['merged_into_id' => null])->save();
+                $result['cleared'][] = $source->number;
+                continue;
+            }
+
+            // `$chain === $source->id` cannot be produced by `merge()` (it
+            // refuses a merged source and a self-merge), but a cycle would make
+            // the row point at itself, which is worse than un-merging it.
+            if ($chain !== null && $chain !== $source->id) {
+                $chainTicket = Ticket::find($chain);
+
+                if ($chainTicket) {
+                    $source->forceFill(['merged_into_id' => $chainTicket->id])->save();
+
+                    TicketMessage::system($source, sprintf(
+                        'Ticket %s was deleted. This ticket had been merged into it, and %s '
+                        .'had itself been merged into %s — where its messages now live — so it '
+                        .'is recorded as merged into %s.',
+                        $target->number,
+                        $target->number,
+                        $chainTicket->number,
+                        $chainTicket->number,
+                    ));
+
+                    $result['repointed'][] = $source->number;
+                    continue;
+                }
+            }
+
+            self::release(
+                $source,
+                sprintf(
+                    'Ticket %s, which this ticket had been merged into, was deleted. This '
+                    .'ticket has been un-merged so that it is no longer read-only; its status '
+                    .'is now %s.',
+                    $target->number,
+                    Ticket::STATUS_UNMERGED,
+                ),
+                $by,
+            );
+
+            $result['unmerged'][] = $source->number;
+        }
+
+        Log::info(sprintf(
+            '[ticketing] #1567 deleting %s: re-pointed %d, un-merged %d, cleared %d dangling pointer(s) (%s).',
+            $target->number,
+            count($result['repointed']),
+            count($result['unmerged']),
+            count($result['cleared']),
+            $by,
+        ));
+
+        return $result;
+    }
+
+    /**
+     * Un-merge ONE ticket: status to {@see Ticket::STATUS_UNMERGED}, pointer to
+     * NULL, and a system note saying why.
+     *
+     * `forceFill`, not `update([...])`, for the same reason the rest of the merge
+     * code uses it: this is the machinery correcting its own state, and it must
+     * not be routed through anything that treats `merged` as read-only.
+     *
+     * Returns false when the row was not merged at all, so a double-clicked
+     * button and a stale page are no-ops rather than a second write.
+     */
+    public static function release(Ticket $ticket, string $reason, string $by): bool
+    {
+        if (! $ticket->isMerged()) {
+            return false;
+        }
+
+        $ticket->forceFill([
+            'status'         => Ticket::STATUS_UNMERGED,
+            'merged_into_id' => null,
+        ])->save();
+
+        TicketMessage::system($ticket, $reason);
+
+        Log::info(sprintf(
+            '[ticketing] #1567 un-merged %s to %s (%s).',
+            $ticket->number,
+            Ticket::STATUS_UNMERGED,
+            $by,
+        ));
+
+        return true;
+    }
+}

src/Support/TicketingNotifier.php

@@ -0,0 +1,161 @@
+<?php
+
+namespace Dashboard\Ticketing\Support;
+
+use App\Models\User;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Support\Facades\Log;
+
+/**
+ * The ONE place Ticketing reaches into the Notifications platform app (bridge
+ * shape: Dashboard\Tools\Support\ToolsNotifier).
+ *
+ * Issue #8: ticketing had NO notification integration at all — no `ticketing.*`
+ * category existed, so the shared Notification Log listed a category for every
+ * other app and nothing for this one. Note this was not a mail sweep like the
+ * other apps: there was no existing Mail:: call to redirect.
+ * TicketMessageController::notifySubmitter() was an empty stub with the comment
+ * "In production: Mail::to($submitterEmail)->send(new TicketReplyMail(…))", so
+ * nobody has ever been told their ticket was answered.
+ *
+ * TWO CATEGORIES, matching the two moments a person is waiting on somebody else:
+ *
+ *  - ticketing.replied  → the submitter, when an agent answers. Internal notes are
+ *    excluded by the caller: the whole point of an internal note is that the
+ *    submitter does not see it.
+ *  - ticketing.assigned → the agent a ticket has just been handed to. Skipped when
+ *    somebody assigns a ticket to themselves, which needs no telling.
+ *
+ * Neither is mandatory. A reply notice is a convenience, not a security or
+ * financial record, so a person may turn it off in their notification preferences.
+ *
+ * SHIP-DARK SAFETY. available() is false when the platform is absent, and every
+ * caller treats a false return as "nothing was sent" rather than an error — there is
+ * no direct-mail fallback to run, because there was never any direct mail here.
+ * DELIBERATELY NOT a manifest dependency: requires.apps is a HARD requirement (a
+ * merely-disabled dep fails dashboard:doctor, which gates update.sh and promote.sh),
+ * and Notifications is a beta app that ships dark. Add it once Notifications is
+ * stability: stable.
+ */
+final class TicketingNotifier
+{
+    public const REPLIED = 'ticketing.replied';
+
+    public const ASSIGNED = 'ticketing.assigned';
+
+    /** @var array<string, array{0:string,1:string}> key => [label, description] */
+    public const CATEGORIES = [
+        self::REPLIED => [
+            'Your help desk ticket was answered',
+            'Sent to the person who raised a ticket when an agent replies. Internal notes never trigger this.',
+            ['staff', 'student'],
+        ],
+        self::ASSIGNED => [
+            'A help desk ticket was assigned to you',
+            'Sent to an agent when a ticket is assigned to them by somebody else.',
+            ['staff'],
+        ],
+    ];
+
+    /** Test hook — behave as though Notifications isn't installed. */
+    private static bool $pretendMissing = false;
+
+    public static function available(): bool
+    {
+        return ! self::$pretendMissing
+            && class_exists(\Central\Notifications\Support\Notify::class)
+            && class_exists(\Central\Notifications\Support\Message::class);
+    }
+
+    public static function pretendPlatformMissing(bool $missing = true): void
+    {
+        self::$pretendMissing = $missing;
+    }
+
+    /** Declare the categories. Called from TicketingServiceProvider::boot(). */
+    public static function registerCategories(): void
+    {
+        if (! class_exists(\Central\Notifications\Support\NotificationRegistry::class)) {
+            return;
+        }
+
+        try {
+            foreach (self::CATEGORIES as $key => [$label, $description, $audience]) {
+                \Central\Notifications\Support\NotificationRegistry::register(
+                    $key, $label, $description, ['mail'], mandatory: false, audience: $audience,
+                );
+            }
+        } catch (\Throwable $e) {
+            Log::warning('Ticketing: could not register notification categories: '.$e->getMessage());
+        }
+    }
+
+    /**
+     * Queue one email through the platform.
+     *
+     * PASS THE PERSON, NOT THE ADDRESS, whenever we have one.
+     *
+     * This took a bare string, and `Notify::sendAll()` derives everything
+     * user-shaped from the recipient it is handed: `$user = $recipient instanceof
+     * User ? $recipient : null`. With a string there is no `$user`, so three
+     * things silently went missing at once, all from the same line:
+     *
+     *  - `to_user_id` was null, so the send never appeared in that person's
+     *    notification history;
+     *  - `to_name` was null, so the shared Notification Log fell through to its
+     *    "we don't know who this went to" rendering and printed the message TYPE
+     *    where the recipient's name belongs — for people we plainly do know, since
+     *    both our notifications go to a Central user by definition (a ticket's
+     *    submitter, or the agent it was just assigned to);
+     *  - the preference branch is guarded by `if ($user && ! $mandatory && …)`, so
+     *    it was skipped entirely and **the opt-out did nothing**. Neither of our
+     *    categories is mandatory, so My Notifications offered a switch that was
+     *    never read.
+     *
+     * A bare string is still accepted, for a future send to an address with no
+     * account behind it. It is simply no longer what our own callers hand over.
+     *
+     * Note we no longer resolve the address by hand either: `Notify` resolves a
+     * User school → personal → login, which is the platform's answer to "where do
+     * we email this person" and is what every other app gets.
+     *
+     * @param  User|string  $to  the recipient — a User wherever one is known
+     * @return array{handled:bool,status:?string,error:?string,id:?int}
+     */
+    public static function deliver(
+        string $category,
+        User|string $to,
+        string $subject,
+        string $bodyHtml,
+        ?Model $context = null,
+    ): array {
+        $unhandled = ['handled' => false, 'status' => null, 'error' => null, 'id' => null];
+
+        if (! self::available() || (is_string($to) && trim($to) === '')) {
+            return $unhandled;
+        }
+
+        try {
+            $row = \Central\Notifications\Support\Notify::send(new \Central\Notifications\Support\Message(
+                category: $category,
+                to: $to,
+                subject: $subject,
+                body: $bodyHtml,
+                context: $context,
+            ));
+        } catch (\Throwable $e) {
+            // Never let a notification failure break the action that caused it:
+            // sending a reply must succeed even if the email cannot be queued.
+            Log::warning("Ticketing: notification '{$category}' could not be queued: ".$e->getMessage());
+
+            return $unhandled;
+        }
+
+        return [
+            'handled' => true,
+            'status'  => $row->status,
+            'error'   => $row->status === 'failed' ? ($row->error ?: 'The notification could not be queued.') : null,
+            'id'      => $row->id,
+        ];
+    }
+}

src/TicketingServiceProvider.php

@@ -2,21 +2,222 @@
 
 namespace Dashboard\Ticketing;
 
+use Illuminate\Console\Scheduling\Schedule;
 use Illuminate\Support\ServiceProvider;
 
 class TicketingServiceProvider extends ServiceProvider
 {
-    public function register(): void {}
+    public function register(): void
+    {
+        // Merge so config('ticketing.*') resolves even when the host app has not
+        // published a copy — and, crucially, so the value is captured by
+        // config:cache instead of being read from env() at runtime (S3).
+        $this->mergeConfigFrom(__DIR__.'/../config/ticketing.php', 'ticketing');
+    }
 
     public function boot(): void
     {
         $this->loadMigrationsFrom(__DIR__.'/../database/migrations');
         $this->loadRoutesFrom(__DIR__.'/routes/ticketing.php');
 
+        // Declare ticketing.* notification categories (issue #8). Safe to call when
+        // 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 four
+     * 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.
+     *
+     * ── 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 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),
+            );
+        } catch (\Throwable) {
+            // Never let a declaration break boot.
+        }
     }
 }

src/routes/ticketing.php

@@ -13,8 +13,20 @@ Route::middleware(['web', 'auth', 'app.access:ticketing'])
 
         // ── Fixed paths first (before any /{ticket} wildcards) ────────────────
 
-        Route::get('/my-tickets', [TicketController::class, 'myTickets'])->name('my-tickets');
-        Route::post('/prefs',     [TicketController::class, 'savePrefs']) ->name('prefs.save');
+        // my-tickets and prefs carried only `app.access:ticketing`, which means "you hold
+        // ANY ticketing.* permission" — so ticketing.settings alone opened them. They are
+        // the submitter's own surface, and ticketing.view is literally described as
+        // "Submit tickets and view own ticket history", so it is the right key; managers
+        // hold it implicitly via the same either-or the rest of this file uses.
+        Route::middleware('permission:ticketing.view,ticketing.manage')->group(function () {
+            Route::get('/my-tickets', [TicketController::class, 'myTickets'])->name('my-tickets');
+            Route::post('/prefs',     [TicketController::class, 'savePrefs']) ->name('prefs.save');
+        });
+
+        // Attachments stay ungated ON PURPOSE: TicketAttachmentController::show already
+        // authorises submitter-or-agent per attachment, which is finer than any
+        // permission could be. A key here would either duplicate that check or
+        // contradict it.
         Route::get('/attachments/{attachment}', [TicketAttachmentController::class, 'show'])->name('attachments.show');
 
         Route::middleware('permission:ticketing.view,ticketing.manage')->group(function () {
@@ -29,10 +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');
@@ -62,6 +89,10 @@ Route::middleware(['web', 'auth', 'app.access:ticketing'])
             Route::post('/{ticket}/view',                     [TicketController::class, 'recordView'])        ->name('tickets.view');
             Route::post('/{ticket}/merge',                    [TicketController::class, 'merge'])             ->name('merge');
             Route::post('/{ticket}/split',                    [TicketController::class, 'split'])             ->name('split');
+            // #938 — the one-click fix for a row the merge bug left inconsistent.
+            Route::post('/{ticket}/mark-merged',              [TicketController::class, 'markMerged'])        ->name('mark-merged');
+            // #1567 — the one-click release for a row whose merge target was deleted.
+            Route::post('/{ticket}/unmerge',                  [TicketController::class, 'unmerge'])           ->name('unmerge');
             Route::post('/{ticket}/participants',             [TicketController::class, 'addParticipant'])    ->name('participants.store');
             Route::delete('/{ticket}/participants/{userId}',  [TicketController::class, 'removeParticipant'])->name('participants.destroy');
             Route::get('/{ticket}/users/search',              [TicketController::class, 'searchUsers'])       ->name('users.search');