@consilioweb/payload-support 0.15.0 → 0.16.0

package/src/collections/TicketMessages.ts

@@ -30,8 +30,16 @@ function createAutoUpdateStatus(slugs: CollectionSlugs): CollectionAfterChangeHo
       if (!doc.isInternal) {
         if (doc.authorType === 'admin') {
           updateData.status = 'waiting_client'
+          // A fresh public reply starts a new waiting window: drop any pending
+          // auto-close arming (manual deadline + day-based reminder anchor) so
+          // reminders re-arm cleanly from here.
+          updateData.autoCloseScheduledAt = null
+          updateData.autoCloseRemindedAt = null
         } else if (doc.authorType === 'client' || doc.authorType === 'email') {
           updateData.lastClientMessageAt = new Date().toISOString()
+          // The client answered — cancel any pending automatic closure.
+          updateData.autoCloseScheduledAt = null
+          updateData.autoCloseRemindedAt = null
           if (ticket.status && ['waiting_client', 'resolved'].includes(ticket.status as string)) {
             updateData.status = 'open'
           }

package/src/collections/Tickets.ts

@@ -739,6 +739,7 @@ export function createTicketsCollection(slugs: CollectionSlugs, options?: {
           },
           { name: 'mergedInto', type: 'relationship', relationTo: slugs.tickets, label: 'Fusionne dans', admin: { readOnly: true } },
           { name: 'autoCloseRemindedAt', type: 'date', label: 'Rappel auto-close envoye', admin: { readOnly: true, date: { displayFormat: 'dd/MM/yyyy HH:mm' } } },
+          { name: 'autoCloseScheduledAt', type: 'date', label: 'Fermeture auto programmee', admin: { readOnly: true, date: { displayFormat: 'dd/MM/yyyy HH:mm' }, description: 'Echeance ferme posee par une relance manuelle. Le ticket se ferme apres cette date sans reponse client.' } },
         ],
       },
       // Sidebar

package/src/components/TicketConversation/components/ActionPanels.tsx

@@ -1,7 +1,7 @@
 'use client'
 
 import React, { useRef } from 'react'
-import { s } from '../constants'
+import { C, s } from '../constants'
 
 // ========== MERGE PANEL ==========
 interface MergePanelProps {
@@ -115,6 +115,87 @@ export function ExtMessagePanel({
   )
 }
 
+// ========== REMINDER PANEL ==========
+interface ReminderPanelProps {
+  clientFirstName: string
+  clientEmail: string
+  reminderHours: number
+  setReminderHours: (v: number) => void
+  reminderSending: boolean
+  reminderError: string
+  handleSendReminder: () => void
+}
+
+const REMINDER_DELAYS = [
+  { hours: 24, label: '24 h' },
+  { hours: 48, label: '48 h' },
+  { hours: 72, label: '72 h' },
+]
+
+export function ReminderPanel({
+  clientFirstName, clientEmail, reminderHours, setReminderHours,
+  reminderSending, reminderError, handleSendReminder,
+}: ReminderPanelProps) {
+  const deadline = new Date(Date.now() + reminderHours * 60 * 60 * 1000)
+  const deadlineLabel = deadline.toLocaleString('fr-FR', {
+    weekday: 'long', day: 'numeric', month: 'long', hour: '2-digit', minute: '2-digit',
+  })
+  const name = clientFirstName?.trim() || 'le client'
+
+  return (
+    <div style={{ padding: '14px 18px', borderRadius: '8px', backgroundColor: '#fff7ed', border: '1px solid #fed7aa', marginBottom: '14px' }}>
+      <h4 style={{ fontSize: '13px', fontWeight: 600, marginBottom: '8px', color: '#9a3412' }}>
+        Relancer {name} — fermeture automatique sans réponse
+      </h4>
+      {clientEmail ? (
+        <p style={{ fontSize: '12px', color: '#7c2d12', margin: '0 0 12px 0', lineHeight: 1.5 }}>
+          Un email de relance générique sera envoyé à <strong>{clientEmail}</strong>. Sans retour de sa part avant l&apos;échéance, le ticket sera automatiquement résolu (via le cron auto-close).
+        </p>
+      ) : (
+        <p style={{ fontSize: '12px', color: '#b91c1c', margin: '0 0 12px 0', fontWeight: 600 }}>
+          Ce client n&apos;a pas d&apos;adresse email : impossible d&apos;envoyer une relance.
+        </p>
+      )}
+
+      <div style={{ display: 'flex', gap: '6px', alignItems: 'center', flexWrap: 'wrap', marginBottom: '12px' }}>
+        <span style={{ fontSize: '12px', fontWeight: 600, color: '#9a3412' }}>Fermer dans :</span>
+        {REMINDER_DELAYS.map((d) => {
+          const active = reminderHours === d.hours
+          return (
+            <button
+              key={d.hours}
+              type="button"
+              onClick={() => setReminderHours(d.hours)}
+              style={{
+                ...(active ? s.btn(C.orange) : s.outlineBtn('#ea580c')),
+                fontSize: '12px', padding: '6px 14px',
+              }}
+            >
+              {d.label}
+            </button>
+          )
+        })}
+      </div>
+
+      <div style={{ fontSize: '12px', color: '#7c2d12', marginBottom: '12px' }}>
+        Fermeture automatique prévue le <strong>{deadlineLabel}</strong> sans réponse.
+      </div>
+
+      {reminderError && (
+        <div style={{ fontSize: '12px', color: '#b91c1c', fontWeight: 600, marginBottom: '10px' }}>{reminderError}</div>
+      )}
+
+      <button
+        onClick={handleSendReminder}
+        disabled={reminderSending || !clientEmail}
+        style={{ ...s.btn(C.orange, reminderSending || !clientEmail), color: '#fff', fontSize: '13px', padding: '8px 18px' }}
+      >
+        {reminderSending ? 'Envoi...' : 'Confirmer la relance'}
+      </button>
+    </div>
+  )
+}
+
 // ========== SNOOZE PANEL ==========
 interface SnoozePanelProps {
   snoozeSaving: boolean

package/src/components/TicketConversation/components/QuickActions.tsx

@@ -18,6 +18,13 @@ interface QuickActionsProps {
   onToggleExtMsg: () => void
   onToggleSnooze: () => void
   onNextTicket: () => void
+  // Reminder (relance + auto-close)
+  showReminderButton: boolean
+  onToggleReminder: () => void
+  autoCloseScheduledAt: string | null
+  onCancelScheduledClose: () => void
+  cancelingClose: boolean
+  reminderSuccess: boolean
   // Next ticket banner
   showNextTicket: boolean
   nextTicketId: number | null
@@ -30,8 +37,12 @@ export function QuickActions({
   snoozeUntil, snoozeSaving, onCancelSnooze,
   showMerge: _showMerge, showExtMsg: _showExtMsg, showSnooze: _showSnooze,
   onToggleMerge, onToggleExtMsg, onToggleSnooze, onNextTicket,
+  showReminderButton, onToggleReminder, autoCloseScheduledAt, onCancelScheduledClose, cancelingClose, reminderSuccess,
   showNextTicket, nextTicketId, nextTicketInfo, onCloseNextTicket,
 }: QuickActionsProps) {
+  const scheduledClose = autoCloseScheduledAt && new Date(autoCloseScheduledAt) > new Date()
+    ? new Date(autoCloseScheduledAt).toLocaleString('fr-FR', { day: 'numeric', month: 'short', hour: '2-digit', minute: '2-digit' })
+    : null
   return (
     <>
       <div style={{ display: 'flex', gap: '8px', flexWrap: 'wrap', marginBottom: '16px', alignItems: 'center' }}>
@@ -54,7 +65,21 @@ export function QuickActions({
         <button onClick={onToggleMerge} style={s.ghostBtn('#be185d')}>Fusionner</button>
         <button onClick={onToggleExtMsg} style={s.ghostBtn('#4f46e5')}>+ Message reçu</button>
         <button onClick={onToggleSnooze} style={s.ghostBtn('#7c3aed')}>Snooze</button>
+        {showReminderButton && (
+          <button onClick={onToggleReminder} style={s.ghostBtn('#ea580c')}>{'⏰'} Relancer</button>
+        )}
         <button onClick={onNextTicket} style={s.ghostBtn('#16a34a')}>Ticket suivant</button>
+        {scheduledClose && (
+          <span style={{ display: 'inline-flex', alignItems: 'center', gap: '8px', padding: '5px 10px', borderRadius: '6px', backgroundColor: '#fff7ed', border: '1px solid #fed7aa', fontSize: '12px', color: '#9a3412', fontWeight: 600 }}>
+            {'⏰'} Fermeture auto le {scheduledClose}
+            <button onClick={onCancelScheduledClose} disabled={cancelingClose} style={{ border: 'none', background: 'none', color: '#b91c1c', cursor: cancelingClose ? 'not-allowed' : 'pointer', fontWeight: 700, fontSize: '12px', textDecoration: 'underline', padding: 0, opacity: cancelingClose ? 0.5 : 1 }}>
+              {cancelingClose ? '...' : 'Annuler'}
+            </button>
+          </span>
+        )}
+        {reminderSuccess && (
+          <span style={{ ...s.badge('#f0fdf4', '#16a34a'), fontSize: '12px', padding: '5px 10px' }}>Relance envoyée {'✓'}</span>
+        )}
       </div>
 
       {showNextTicket && (

package/src/components/TicketConversation/hooks/useTicketActions.ts

@@ -23,6 +23,13 @@ export function useTicketActions(
   const [showSnooze, setShowSnooze] = useState(false)
   const [snoozeUntil, setSnoozeUntil] = useState<string | null>(null)
   const [snoozeSaving, setSnoozeSaving] = useState(false)
+  // Reminder (relance + auto-close arming)
+  const [showReminder, setShowReminder] = useState(false)
+  const [reminderHours, setReminderHours] = useState(24)
+  const [reminderSending, setReminderSending] = useState(false)
+  const [reminderError, setReminderError] = useState('')
+  const [reminderSuccess, setReminderSuccess] = useState(false)
+  const [cancelingClose, setCancelingClose] = useState(false)
   // Next ticket
   const [showNextTicket, setShowNextTicket] = useState(false)
   const [nextTicketId, setNextTicketId] = useState<number | null>(null)
@@ -178,6 +185,49 @@ export function useTicketActions(
     }
   }
 
+  const handleSendReminder = async () => {
+    if (!id) return
+    setReminderSending(true)
+    setReminderError('')
+    try {
+      const res = await fetch('/api/support/send-reminder', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        credentials: 'include',
+        body: JSON.stringify({ ticketId: id, hours: reminderHours }),
+      })
+      const d = await res.json().catch(() => ({}))
+      if (res.ok) {
+        setShowReminder(false)
+        setReminderSuccess(true)
+        setTimeout(() => setReminderSuccess(false), 5000)
+        fetchAll()
+      } else {
+        setReminderError(d.error || 'Erreur lors de la relance')
+      }
+    } catch {
+      setReminderError('Erreur réseau')
+    } finally {
+      setReminderSending(false)
+    }
+  }
+
+  const handleCancelScheduledClose = async () => {
+    if (!id) return
+    setCancelingClose(true)
+    try {
+      await fetch(`/api/tickets/${id}`, {
+        method: 'PATCH',
+        headers: { 'Content-Type': 'application/json' },
+        credentials: 'include',
+        body: JSON.stringify({ autoCloseScheduledAt: null, autoCloseRemindedAt: null }),
+      })
+      fetchAll()
+    } catch { /* ignore */ } finally {
+      setCancelingClose(false)
+    }
+  }
+
   const handleNextTicket = async () => {
     try {
       const res = await fetch('/api/tickets?where[status][equals]=open&sort=updatedAt&limit=1&depth=0', { credentials: 'include' })
@@ -200,6 +250,7 @@ export function useTicketActions(
     showMerge, setShowMerge, mergeTarget, setMergeTarget, mergeTargetInfo, setMergeTargetInfo, mergeError, setMergeError, merging, handleMergeLookup, handleMerge,
     showExtMsg, setShowExtMsg, extMsgBody, setExtMsgBody, extMsgAuthor, setExtMsgAuthor, extMsgDate, setExtMsgDate, extMsgFiles, setExtMsgFiles, sendingExtMsg, handleExtFileChange, handleSendExtMsg,
     showSnooze, setShowSnooze, snoozeUntil, setSnoozeUntil, snoozeSaving, handleSnooze,
+    showReminder, setShowReminder, reminderHours, setReminderHours, reminderSending, reminderError, setReminderError, reminderSuccess, handleSendReminder, cancelingClose, handleCancelScheduledClose,
     showNextTicket, setShowNextTicket, nextTicketId, nextTicketInfo, handleNextTicket,
   }
 }

package/src/components/TicketConversation/index.tsx

@@ -31,7 +31,7 @@ import { TicketHeader } from './components/TicketHeader'
 import { ClientBar } from './components/ClientBar'
 import { QuickActions } from './components/QuickActions'
 import { AISummaryPanel } from './components/AISummaryPanel'
-import { MergePanel, ExtMessagePanel, SnoozePanel } from './components/ActionPanels'
+import { MergePanel, ExtMessagePanel, SnoozePanel, ReminderPanel } from './components/ActionPanels'
 import { ActivityLog } from './components/ActivityLog'
 import { ClientHistory } from './components/ClientHistory'
 import { TimeTrackingPanel } from './components/TimeTrackingPanel'
@@ -201,6 +201,7 @@ const TicketConversation: React.FC = () => {
   const [ticketSubject, setTicketSubject] = useState<string>('')
   const [ticketSource, setTicketSource] = useState<string>('')
   const [chatSession, setChatSession] = useState<string>('')
+  const [autoCloseScheduledAt, setAutoCloseScheduledAt] = useState<string | null>(null)
   // Client history
   const [clientTickets, setClientTickets] = useState<Array<{ id: number; ticketNumber: string; subject: string; status: string; createdAt: string }>>([])
   const [clientProjects, setClientProjects] = useState<Array<{ id: number; name: string; status: string }>>([])
@@ -236,6 +237,7 @@ const TicketConversation: React.FC = () => {
           setClient(d.client)
         }
         setSnoozeUntil(d.snoozeUntil || null)
+        setAutoCloseScheduledAt(d.autoCloseScheduledAt || null)
         setLastClientReadAt(d.lastClientReadAt || null)
         setCurrentStatus(d.status || '')
         setTicketNumber(d.ticketNumber || '')
@@ -384,7 +386,7 @@ const TicketConversation: React.FC = () => {
 
   // Ticket actions (status, merge, snooze, ext msg, next ticket)
   const ta = useTicketActions(id, fetchAll)
-  const { statusUpdating, handleStatusChange, showMerge, setShowMerge, mergeTarget, setMergeTarget, mergeTargetInfo, setMergeTargetInfo, mergeError, setMergeError, merging, handleMergeLookup, handleMerge, showExtMsg, setShowExtMsg, extMsgBody, setExtMsgBody, extMsgAuthor, setExtMsgAuthor, extMsgDate, setExtMsgDate, extMsgFiles, setExtMsgFiles, sendingExtMsg, handleExtFileChange, handleSendExtMsg, showSnooze, setShowSnooze, snoozeUntil, setSnoozeUntil, snoozeSaving, handleSnooze, showNextTicket, setShowNextTicket, nextTicketId, nextTicketInfo, handleNextTicket } = ta
+  const { statusUpdating, handleStatusChange, showMerge, setShowMerge, mergeTarget, setMergeTarget, mergeTargetInfo, setMergeTargetInfo, mergeError, setMergeError, merging, handleMergeLookup, handleMerge, showExtMsg, setShowExtMsg, extMsgBody, setExtMsgBody, extMsgAuthor, setExtMsgAuthor, extMsgDate, setExtMsgDate, extMsgFiles, setExtMsgFiles, sendingExtMsg, handleExtFileChange, handleSendExtMsg, showSnooze, setShowSnooze, snoozeUntil, setSnoozeUntil, snoozeSaving, handleSnooze, showReminder, setShowReminder, reminderHours, setReminderHours, reminderSending, reminderError, setReminderError, reminderSuccess, handleSendReminder, cancelingClose, handleCancelScheduledClose, showNextTicket, setShowNextTicket, nextTicketId, nextTicketInfo, handleNextTicket } = ta
 
   // Reply composer
   const replyEditorRef = useRef<RichTextEditorHandle>(null)
@@ -419,6 +421,7 @@ const TicketConversation: React.FC = () => {
           const d = await ticketRes.json()
           setCurrentStatus(d.status || '')
           setSnoozeUntil(d.snoozeUntil || null)
+          setAutoCloseScheduledAt(d.autoCloseScheduledAt || null)
           setLastClientReadAt(d.lastClientReadAt || null)
         }
         if (activityRes.ok) {
@@ -1094,10 +1097,16 @@ const TicketConversation: React.FC = () => {
         showMerge={showMerge}
         showExtMsg={showExtMsg}
         showSnooze={showSnooze}
-        onToggleMerge={() => { setShowMerge(!showMerge); setShowExtMsg(false); setShowSnooze(false) }}
-        onToggleExtMsg={() => { setShowExtMsg(!showExtMsg); setShowMerge(false); setShowSnooze(false) }}
-        onToggleSnooze={() => { setShowSnooze(!showSnooze); setShowMerge(false); setShowExtMsg(false) }}
+        onToggleMerge={() => { setShowMerge(!showMerge); setShowExtMsg(false); setShowSnooze(false); setShowReminder(false) }}
+        onToggleExtMsg={() => { setShowExtMsg(!showExtMsg); setShowMerge(false); setShowSnooze(false); setShowReminder(false) }}
+        onToggleSnooze={() => { setShowSnooze(!showSnooze); setShowMerge(false); setShowExtMsg(false); setShowReminder(false) }}
         onNextTicket={handleNextTicket}
+        showReminderButton={features.autoClose}
+        onToggleReminder={() => { setShowReminder(!showReminder); setReminderError(''); setShowMerge(false); setShowExtMsg(false); setShowSnooze(false) }}
+        autoCloseScheduledAt={autoCloseScheduledAt}
+        onCancelScheduledClose={handleCancelScheduledClose}
+        cancelingClose={cancelingClose}
+        reminderSuccess={reminderSuccess}
         showNextTicket={showNextTicket}
         nextTicketId={nextTicketId}
         nextTicketInfo={nextTicketInfo}
@@ -1139,6 +1148,17 @@ const TicketConversation: React.FC = () => {
       {features.snooze && showSnooze && (
         <SnoozePanel snoozeSaving={snoozeSaving} handleSnooze={handleSnooze} />
       )}
+      {features.autoClose && showReminder && (
+        <ReminderPanel
+          clientFirstName={client?.firstName || ''}
+          clientEmail={client?.email || ''}
+          reminderHours={reminderHours}
+          setReminderHours={setReminderHours}
+          reminderSending={reminderSending}
+          reminderError={reminderError}
+          handleSendReminder={handleSendReminder}
+        />
+      )}
 
 
         </div>

package/src/endpoints/auto-close.ts

@@ -90,7 +90,13 @@ export function createAutoCloseEndpoint(slugs: CollectionSlugs): Endpoint {
           }
         }
 
-        // Step 2: Close tickets that were reminded > CLOSE_AFTER_REMIND_DAYS ago
+        // Step 2: Close tickets that are due. Two independent paths:
+        //  - day-based: reminded > CLOSE_AFTER_REMIND_DAYS ago and the client
+        //    stayed silent (the legacy automatic flow).
+        //  - explicit deadline: a manual reminder armed `autoCloseScheduledAt`
+        //    (e.g. "close in 24h"). When the client replies, that field is
+        //    cleared and the status flips to `open`, so a still-set deadline in
+        //    the past means no reply was received.
         const closeCutoff = new Date(now.getTime() - CLOSE_AFTER_REMIND_DAYS * 24 * 60 * 60 * 1000)
 
         const ticketsToClose = await payload.find({
@@ -98,11 +104,20 @@ export function createAutoCloseEndpoint(slugs: CollectionSlugs): Endpoint {
           where: {
             and: [
               { status: { equals: 'waiting_client' } },
-              { autoCloseRemindedAt: { less_than: closeCutoff.toISOString() } },
               {
                 or: [
-                  { lastClientMessageAt: { exists: false } },
-                  { lastClientMessageAt: { less_than_equal: closeCutoff.toISOString() } },
+                  {
+                    and: [
+                      { autoCloseRemindedAt: { less_than: closeCutoff.toISOString() } },
+                      {
+                        or: [
+                          { lastClientMessageAt: { exists: false } },
+                          { lastClientMessageAt: { less_than_equal: closeCutoff.toISOString() } },
+                        ],
+                      },
+                    ],
+                  },
+                  { autoCloseScheduledAt: { less_than_equal: now.toISOString() } },
                 ],
               },
             ],
@@ -119,12 +134,19 @@ export function createAutoCloseEndpoint(slugs: CollectionSlugs): Endpoint {
             const ticketNumber = t.ticketNumber || 'TK-????'
             const subject = t.subject || 'Support'
             const closeTotalDays = REMIND_AFTER_DAYS + CLOSE_AFTER_REMIND_DAYS
+            // Was this ticket closed via a manual reminder's explicit deadline,
+            // or via the legacy day-based flow? Drives the wording below.
+            const viaSchedule = !!t.autoCloseScheduledAt
+              && new Date(t.autoCloseScheduledAt).getTime() <= now.getTime()
+            const noteBody = viaSchedule
+              ? 'Ticket résolu automatiquement — relance manuelle restée sans réponse du client'
+              : `Ticket résolu automatiquement — sans réponse client depuis ${closeTotalDays} jours`
 
             await payload.create({
               collection: slugs.ticketMessages as any,
               data: {
                 ticket: t.id,
-                body: `Ticket résolu automatiquement — sans réponse client depuis ${closeTotalDays} jours`,
+                body: noteBody,
                 authorType: 'admin',
                 isInternal: true,
                 skipNotification: true,
@@ -135,7 +157,9 @@ export function createAutoCloseEndpoint(slugs: CollectionSlugs): Endpoint {
             await payload.update({
               collection: slugs.tickets as any,
               id: t.id,
-              data: { status: 'resolved' },
+              // Clear the armed deadline so a later manual reopen can't be
+              // closed instantly by a stale timestamp.
+              data: { status: 'resolved', autoCloseScheduledAt: null },
               overrideAccess: true,
             })
 
@@ -147,7 +171,7 @@ export function createAutoCloseEndpoint(slugs: CollectionSlugs): Endpoint {
                 subject: `[${ticketNumber}] Ticket résolu — ${subject}`,
                 html: `<div style="font-family: system-ui, sans-serif; max-width: 600px; margin: 0 auto;">
                   <p>Bonjour <strong>${escapeHtml(client.firstName || '')}</strong>,</p>
-                  <p>Votre ticket <strong>${escapeHtml(ticketNumber)}</strong> — <em>${escapeHtml(subject)}</em> — a été résolu automatiquement après ${closeTotalDays} jours sans réponse.</p>
+                  <p>Votre ticket <strong>${escapeHtml(ticketNumber)}</strong> — <em>${escapeHtml(subject)}</em> — a été résolu automatiquement ${viaSchedule ? 'faute de réponse de votre part' : `après ${closeTotalDays} jours sans réponse`}.</p>
                   <p>Si vous avez encore besoin d'aide, n'hésitez pas à rouvrir ce ticket ou à en créer un nouveau.</p>
                   <p><a href="${portalUrl}">Consulter le ticket</a></p>
                 </div>`,

package/src/endpoints/index.ts

@@ -16,6 +16,7 @@ import { createSignatureGetEndpoint, createSignaturePostEndpoint } from './signa
 import { createRoundRobinConfigGetEndpoint, createRoundRobinConfigPostEndpoint } from './round-robin-config'
 import { createSlaCheckEndpoint } from './sla-check'
 import { createAutoCloseEndpoint } from './auto-close'
+import { createSendReminderEndpoint } from './send-reminder'
 import { createStatusesEndpoint } from './statuses'
 import { createApplyMacroEndpoint } from './apply-macro'
 import { createPurgeLogsEndpoint } from './purge-logs'
@@ -62,6 +63,7 @@ export { createSignatureGetEndpoint, createSignaturePostEndpoint } from './signa
 export { createRoundRobinConfigGetEndpoint, createRoundRobinConfigPostEndpoint } from './round-robin-config'
 export { createSlaCheckEndpoint } from './sla-check'
 export { createAutoCloseEndpoint } from './auto-close'
+export { createSendReminderEndpoint } from './send-reminder'
 export { createStatusesEndpoint } from './statuses'
 export { createApplyMacroEndpoint } from './apply-macro'
 export { createPurgeLogsEndpoint } from './purge-logs'
@@ -151,7 +153,10 @@ export function createSupportEndpoints(slugs: CollectionSlugs, options?: Support
     endpoints.push(createSignatureGetEndpoint(slugs), createSignaturePostEndpoint(slugs))
   }
   if (!f || f.sla !== false) endpoints.push(createSlaCheckEndpoint(slugs))
-  if (!f || f.autoClose !== false) endpoints.push(createAutoCloseEndpoint(slugs))
+  if (!f || f.autoClose !== false) {
+    endpoints.push(createAutoCloseEndpoint(slugs))
+    endpoints.push(createSendReminderEndpoint(slugs))
+  }
   if (!f || f.customStatuses !== false) endpoints.push(createStatusesEndpoint(slugs))
   if (!f || f.macros !== false) endpoints.push(createApplyMacroEndpoint(slugs))
   if (!f || f.roundRobin !== false) {

package/src/endpoints/send-reminder.ts

@@ -0,0 +1,189 @@
+import type { Endpoint } from 'payload'
+import type { CollectionSlugs } from '../utils/slugs'
+import { requireAdmin, handleAuthError } from '../utils/auth'
+import { RateLimiter } from '../utils/rateLimiter'
+import { escapeHtml, emailWrapper, emailParagraph, emailButton } from '../utils/emailTemplate'
+import { readSupportSettings } from '../utils/readSettings'
+
+// Manual reminders are a deliberate admin action, so the cap is generous —
+// it only exists to stop a runaway script, not normal usage.
+const reminderLimiter = new RateLimiter(60 * 60 * 1000, 30) // 30 per hour per admin
+
+const MIN_HOURS = 1
+const MAX_HOURS = 24 * 30 // 30 days
+
+function formatFr(date: Date, withTime: boolean): string {
+  return date.toLocaleString('fr-FR', {
+    day: 'numeric',
+    month: 'long',
+    year: 'numeric',
+    ...(withTime ? { hour: '2-digit', minute: '2-digit' } : {}),
+    timeZone: 'Europe/Paris',
+  })
+}
+
+/**
+ * POST /api/support/send-reminder
+ *
+ * Manually nudge a client whose ticket is awaiting their reply: sends a generic
+ * "your ticket will be closed if you don't respond" email, drops an internal
+ * note in the thread, and arms the ticket for automatic closure.
+ *
+ * Arming = set `status: waiting_client`, `autoCloseRemindedAt: now` (so the
+ * day-based cron reminder skips it) and `autoCloseScheduledAt: now + hours`.
+ * The existing `/api/support/auto-close` cron then resolves the ticket once the
+ * deadline passes — UNLESS the client replies first, which flips the status back
+ * to `open` and clears `autoCloseScheduledAt` (see TicketMessages auto-update hook).
+ *
+ * Admin-only, rate-limited.
+ */
+export function createSendReminderEndpoint(slugs: CollectionSlugs): Endpoint {
+  return {
+    path: '/support/send-reminder',
+    method: 'post',
+    handler: async (req) => {
+      try {
+        const payload = req.payload
+
+        requireAdmin(req, slugs)
+
+        if (reminderLimiter.check(String(req.user.id))) {
+          return Response.json(
+            { error: 'Trop de relances. Réessayez dans une heure.' },
+            { status: 429 },
+          )
+        }
+
+        let body: { ticketId?: string | number; hours?: number }
+        try {
+          body = await req.json!()
+        } catch {
+          return Response.json({ error: 'Invalid JSON body' }, { status: 400 })
+        }
+
+        const { ticketId } = body
+        if (!ticketId) {
+          return Response.json({ error: 'ticketId requis' }, { status: 400 })
+        }
+
+        const rawHours = Number(body.hours)
+        const hours = Number.isFinite(rawHours)
+          ? Math.min(MAX_HOURS, Math.max(MIN_HOURS, Math.round(rawHours)))
+          : 24
+
+        const ticket = await payload.findByID({
+          collection: slugs.tickets as any,
+          id: ticketId,
+          depth: 1,
+          overrideAccess: true,
+        }) as any
+
+        if (!ticket) {
+          return Response.json({ error: 'Ticket introuvable' }, { status: 404 })
+        }
+
+        const client = typeof ticket.client === 'object' ? ticket.client : null
+        if (!client?.email) {
+          return Response.json({ error: 'Client sans email' }, { status: 400 })
+        }
+
+        const now = new Date()
+        const deadline = new Date(now.getTime() + hours * 60 * 60 * 1000)
+
+        const settings = await readSupportSettings(payload)
+        const ticketNumber = ticket.ticketNumber || 'TK-????'
+        const subject = ticket.subject || 'Support'
+        const baseUrl = process.env.NEXT_PUBLIC_SERVER_URL || ''
+        const portalUrl = `${baseUrl}/support/tickets/${ticketId}`
+        const replyTo = settings.email.replyToAddress || process.env.SUPPORT_REPLY_TO || ''
+
+        // "En attente depuis le …" — anchored on our last public reply (that's
+        // what the client owes a response to), falling back to the first
+        // response then to ticket creation.
+        let waitingSince: string | undefined = ticket.firstResponseAt || ticket.createdAt
+        try {
+          const lastAdminMsg = await payload.find({
+            collection: slugs.ticketMessages as any,
+            where: {
+              and: [
+                { ticket: { equals: ticketId } },
+                { authorType: { equals: 'admin' } },
+                { isInternal: { equals: false } },
+              ],
+            },
+            sort: '-createdAt',
+            limit: 1,
+            depth: 0,
+            overrideAccess: true,
+          })
+          if (lastAdminMsg.docs.length > 0 && lastAdminMsg.docs[0].createdAt) {
+            waitingSince = lastAdminMsg.docs[0].createdAt as string
+          }
+        } catch { /* fallback already set */ }
+
+        const sinceLabel = waitingSince ? formatFr(new Date(waitingSince), false) : null
+        const deadlineLabel = formatFr(deadline, true)
+
+        await payload.sendEmail({
+          to: client.email,
+          ...(replyTo ? { replyTo } : {}),
+          subject: `Rappel : [${ticketNumber}] ${subject} — votre réponse est attendue`,
+          html: emailWrapper(`Votre ticket attend votre réponse`, [
+            emailParagraph(`Bonjour <strong>${escapeHtml(client.firstName || '')}</strong>,`),
+            emailParagraph(
+              `Votre ticket <strong>${escapeHtml(ticketNumber)}</strong> — <em>${escapeHtml(String(subject))}</em> — est en attente de votre réponse${sinceLabel ? ` depuis le ${escapeHtml(sinceLabel)}` : ''}.`,
+            ),
+            emailParagraph(
+              `<strong>Sans retour de votre part, ce ticket sera automatiquement clôturé le ${escapeHtml(deadlineLabel)}.</strong>`,
+            ),
+            emailParagraph(
+              `Si vous avez encore besoin d'assistance, il vous suffit de répondre à ce message — votre réponse maintiendra le ticket ouvert.`,
+            ),
+            emailButton('Répondre au ticket', portalUrl, 'primary'),
+          ].join(''), {
+            kind: 'alert',
+            preheader: `Sans réponse de votre part, votre ticket ${ticketNumber} sera clôturé le ${deadlineLabel}.`,
+          }),
+        })
+
+        // Internal note for the conversation timeline (never sent to the client).
+        await payload.create({
+          collection: slugs.ticketMessages as any,
+          data: {
+            ticket: ticketId,
+            body: `Relance envoyée à ${client.email}. Fermeture automatique programmée le ${deadlineLabel} sans réponse du client.`,
+            authorType: 'admin',
+            isInternal: true,
+            skipNotification: true,
+          },
+          overrideAccess: true,
+        })
+
+        // Arm the ticket. `autoCloseRemindedAt: now` keeps the day-based cron
+        // reminder from firing a second time; `autoCloseScheduledAt` is the hard
+        // 24h-style deadline the cron close step honours.
+        await payload.update({
+          collection: slugs.tickets as any,
+          id: ticketId,
+          data: {
+            status: 'waiting_client',
+            autoCloseRemindedAt: now.toISOString(),
+            autoCloseScheduledAt: deadline.toISOString(),
+          },
+          overrideAccess: true,
+        })
+
+        return Response.json({
+          success: true,
+          sentTo: client.email,
+          scheduledCloseAt: deadline.toISOString(),
+        })
+      } catch (error) {
+        const authResponse = handleAuthError(error)
+        if (authResponse) return authResponse
+        console.error('[send-reminder] Error:', error)
+        return Response.json({ error: 'Erreur interne' }, { status: 500 })
+      }
+    },
+  }
+}