@consilioweb/payload-support 6.0.1 → 6.0.3

package/dist/index.cjs

@@ -2102,6 +2102,7 @@ function createSlaCheckEndpoint(slugs) {
             slaResolutionDue: true,
             slaFirstResponseBreached: true,
             slaResolutionBreached: true,
+            slaPausedAt: true,
             firstResponseAt: true,
             createdAt: true
           }
@@ -2136,7 +2137,8 @@ function createSlaCheckEndpoint(slugs) {
             }
           }
           if (t.slaResolutionDue) {
-            const deadline = new Date(t.slaResolutionDue);
+            const pausedMs = t.slaPausedAt ? Math.max(0, now.getTime() - new Date(t.slaPausedAt).getTime()) : 0;
+            const deadline = new Date(new Date(t.slaResolutionDue).getTime() + pausedMs);
             if (now > deadline) {
               ticketData.breachTypes.push("resolution");
             } else {
@@ -8057,7 +8059,8 @@ function createCheckSlaOnResolve(slugs, notificationSlug = "admin-notifications"
     try {
       const { payload } = req;
       const now = /* @__PURE__ */ new Date();
-      const deadline = new Date(doc.slaResolutionDue);
+      const pausedMs = doc.slaPausedAt ? Math.max(0, now.getTime() - new Date(doc.slaPausedAt).getTime()) : 0;
+      const deadline = new Date(new Date(doc.slaResolutionDue).getTime() + pausedMs);
       const breached = now > deadline;
       await dbUpdate(payload, slugs.tickets, {
         id: doc.id,

package/dist/index.js

@@ -2093,6 +2093,7 @@ function createSlaCheckEndpoint(slugs) {
             slaResolutionDue: true,
             slaFirstResponseBreached: true,
             slaResolutionBreached: true,
+            slaPausedAt: true,
             firstResponseAt: true,
             createdAt: true
           }
@@ -2127,7 +2128,8 @@ function createSlaCheckEndpoint(slugs) {
             }
           }
           if (t.slaResolutionDue) {
-            const deadline = new Date(t.slaResolutionDue);
+            const pausedMs = t.slaPausedAt ? Math.max(0, now.getTime() - new Date(t.slaPausedAt).getTime()) : 0;
+            const deadline = new Date(new Date(t.slaResolutionDue).getTime() + pausedMs);
             if (now > deadline) {
               ticketData.breachTypes.push("resolution");
             } else {
@@ -8048,7 +8050,8 @@ function createCheckSlaOnResolve(slugs, notificationSlug = "admin-notifications"
     try {
       const { payload } = req;
       const now = /* @__PURE__ */ new Date();
-      const deadline = new Date(doc.slaResolutionDue);
+      const pausedMs = doc.slaPausedAt ? Math.max(0, now.getTime() - new Date(doc.slaPausedAt).getTime()) : 0;
+      const deadline = new Date(new Date(doc.slaResolutionDue).getTime() + pausedMs);
       const breached = now > deadline;
       await dbUpdate(payload, slugs.tickets, {
         id: doc.id,

package/dist/styles/TicketInbox.module.scss

@@ -286,6 +286,10 @@
 .slaOk     { color: var(--theme-elevation-400); }
 .slaWarn   { color: var(--theme-warning-500, #c97a0a); font-weight: 600; }
 .slaBreach { color: var(--theme-error-500, #c4392c); font-weight: 700; }
+// Paused: deliberately neutral and italic. The clock is stopped because the
+// team is waiting on the client, so this is not a state anyone should act on —
+// it must not compete with the warn and breach colours next to it.
+.slaPaused { color: var(--theme-elevation-650); font-style: italic; }
 
 .timeAgo {
   font-size: 12px;

package/dist/views/TicketInboxView/client.js

@@ -105,11 +105,13 @@ const TicketInboxClient = () => {
       `select[slaFirstResponseBreached]=true`,
       `select[slaResolutionDue]=true`,
       `select[slaResolutionBreached]=true`,
+      `select[slaPausedAt]=true`,
       `select[firstResponseAt]=true`
     ];
     if (tab === "sla_breach") {
       params.push(`where[or][0][slaFirstResponseBreached][equals]=true`);
       params.push(`where[or][1][slaResolutionBreached][equals]=true`);
+      params.push(`where[slaPausedAt][exists]=false`);
     } else if (tab !== "all") {
       params.push(`where[status][equals]=${tab}`);
     }
@@ -146,7 +148,7 @@ const TicketInboxClient = () => {
           fetch(`/api/tickets/count?where[status][equals]=open&${sn}`, { credentials: "include" }),
           fetch(`/api/tickets/count?where[status][equals]=waiting_client&${sn}`, { credentials: "include" }),
           fetch(`/api/tickets/count?where[status][equals]=resolved&${sn}`, { credentials: "include" }),
-          fetch(`/api/tickets/count?where[or][0][slaFirstResponseBreached][equals]=true&where[or][1][slaResolutionBreached][equals]=true&${sn}`, { credentials: "include" })
+          fetch(`/api/tickets/count?where[or][0][slaFirstResponseBreached][equals]=true&where[or][1][slaResolutionBreached][equals]=true&where[slaPausedAt][exists]=false&${sn}`, { credentials: "include" })
         ]);
         const [a, o, w, r, b] = await Promise.all([all.json(), openRes.json(), waiting.json(), resolved.json(), breach.json()]);
         setCounts({
@@ -300,6 +302,7 @@ const TicketInboxClient = () => {
       const priorityColor = PRIORITY_COLORS[tk.priority] || "transparent";
       const sla = computeSlaState(tk);
       const isBreach = sla.state === "breach";
+      const isPaused = sla.state === "paused";
       const statusVariant = STATUS_VARIANT[tk.status] || "open";
       return /* @__PURE__ */ jsxs(
         "a",
@@ -347,10 +350,11 @@ const TicketInboxClient = () => {
                   s.slaCell,
                   sla.state === "breach" ? s.slaBreach : "",
                   sla.state === "warn" ? s.slaWarn : "",
-                  sla.state === "ok" ? s.slaOk : ""
+                  sla.state === "ok" ? s.slaOk : "",
+                  isPaused ? s.slaPaused : ""
                 ].filter(Boolean).join(" "),
-                title: sla.due ? new Date(sla.due).toLocaleString(DATE_LOCALE) : "",
-                children: formatSlaRemaining(sla.remainingMs)
+                title: isPaused ? t("inbox.slaPausedTitle", { since: formatSlaRemaining(sla.pausedMs ?? 0) }) : sla.due ? new Date(sla.due).toLocaleString(DATE_LOCALE) : "",
+                children: isPaused ? t("inbox.slaPaused") : formatSlaRemaining(sla.remainingMs)
               }
             ),
             /* @__PURE__ */ jsx("span", { className: s.timeAgo, children: relativeTime(tk.updatedAt, t) }),

package/dist/views/shared/locales/en.json

@@ -348,7 +348,9 @@
       "responseAwaitedFor": "Awaiting for {{duration}}",
       "target": "Due: {{target}}",
       "escalate": "Escalate"
-    }
+    },
+    "slaPaused": "paused",
+    "slaPausedTitle": "SLA paused for {since} — the clock resumes when the client replies"
   },
   "emailTracking": {
     "title": "Email tracking",
@@ -695,19 +697,58 @@
     "saved2": "✓ Saved",
     "saveChanges": "Save changes",
     "features": {
-      "canned": { "label": "Quick replies", "description": "Pre-registered response templates with dynamic variables" },
-      "scheduledReplies": { "label": "Scheduled replies", "description": "Send a reply at a future date/time" },
-      "activityLog": { "label": "Activity log", "description": "Timeline of actions on each ticket (status changes, assignment...)" },
-      "emailTracking": { "label": "Email tracking", "description": "Send and open tracking for email notifications" },
-      "chat": { "label": "Live Chat", "description": "Real-time chat with ticket conversion" },
-      "externalMessages": { "label": "External messages", "description": "Manually add messages received by email, SMS, WhatsApp..." },
-      "ai": { "label": "Artificial Intelligence", "description": "Sentiment analysis, summary, reply suggestion, rewriting" },
-      "timeTracking": { "label": "Time tracking", "description": "Timer, manual entries, billing" },
-      "satisfaction": { "label": "Satisfaction surveys", "description": "CSAT score after ticket resolution" },
-      "merge": { "label": "Ticket merge", "description": "Combine two tickets into one" },
-      "splitTicket": { "label": "Message extraction", "description": "Extract a message into a new linked ticket" },
-      "snooze": { "label": "Snooze", "description": "Temporarily hide a ticket with automatic reminder" },
-      "clientHistory": { "label": "Client history", "description": "Past tickets, projects and internal notes" }
+      "canned": {
+        "label": "Quick replies",
+        "description": "Pre-registered response templates with dynamic variables"
+      },
+      "scheduledReplies": {
+        "label": "Scheduled replies",
+        "description": "Send a reply at a future date/time"
+      },
+      "activityLog": {
+        "label": "Activity log",
+        "description": "Timeline of actions on each ticket (status changes, assignment...)"
+      },
+      "emailTracking": {
+        "label": "Email tracking",
+        "description": "Send and open tracking for email notifications"
+      },
+      "chat": {
+        "label": "Live Chat",
+        "description": "Real-time chat with ticket conversion"
+      },
+      "externalMessages": {
+        "label": "External messages",
+        "description": "Manually add messages received by email, SMS, WhatsApp..."
+      },
+      "ai": {
+        "label": "Artificial Intelligence",
+        "description": "Sentiment analysis, summary, reply suggestion, rewriting"
+      },
+      "timeTracking": {
+        "label": "Time tracking",
+        "description": "Timer, manual entries, billing"
+      },
+      "satisfaction": {
+        "label": "Satisfaction surveys",
+        "description": "CSAT score after ticket resolution"
+      },
+      "merge": {
+        "label": "Ticket merge",
+        "description": "Combine two tickets into one"
+      },
+      "splitTicket": {
+        "label": "Message extraction",
+        "description": "Extract a message into a new linked ticket"
+      },
+      "snooze": {
+        "label": "Snooze",
+        "description": "Temporarily hide a ticket with automatic reminder"
+      },
+      "clientHistory": {
+        "label": "Client history",
+        "description": "Past tickets, projects and internal notes"
+      }
     },
     "categories": {
       "core": "Core features",

package/dist/views/shared/locales/fr.json

@@ -348,7 +348,9 @@
       "responseAwaitedFor": "En attente depuis {{duration}}",
       "target": "Échéance : {{target}}",
       "escalate": "Escalader"
-    }
+    },
+    "slaPaused": "en pause",
+    "slaPausedTitle": "SLA en pause depuis {since} — le compteur repart à la réponse du client"
   },
   "emailTracking": {
     "title": "Suivi des emails",
@@ -695,19 +697,58 @@
     "saved2": "✓ Sauvegardé",
     "saveChanges": "Sauvegarder les modifications",
     "features": {
-      "canned": { "label": "Réponses rapides", "description": "Templates de réponses pré-enregistrées avec variables dynamiques" },
-      "scheduledReplies": { "label": "Réponses programmées", "description": "Envoyer une réponse à une date/heure future" },
-      "activityLog": { "label": "Journal d'activité", "description": "Timeline des actions sur chaque ticket (changements de statut, assignation...)" },
-      "emailTracking": { "label": "Suivi des emails", "description": "Tracking d'envoi et d'ouverture des notifications email" },
-      "chat": { "label": "Live Chat", "description": "Chat en temps réel avec conversion en ticket" },
-      "externalMessages": { "label": "Messages externes", "description": "Ajouter manuellement des messages reçus par email, SMS, WhatsApp..." },
-      "ai": { "label": "Intelligence Artificielle", "description": "Analyse de sentiment, synthèse, suggestion de réponse, reformulation" },
-      "timeTracking": { "label": "Suivi du temps", "description": "Timer, entrées manuelles, facturation" },
-      "satisfaction": { "label": "Enquêtes satisfaction", "description": "Score CSAT après résolution du ticket" },
-      "merge": { "label": "Fusion de tickets", "description": "Combiner deux tickets en un seul" },
-      "splitTicket": { "label": "Extraction de message", "description": "Extraire un message en nouveau ticket lié" },
-      "snooze": { "label": "Snooze", "description": "Masquer temporairement un ticket et rappel automatique" },
-      "clientHistory": { "label": "Historique client", "description": "Tickets passés, projets et notes internes du client" }
+      "canned": {
+        "label": "Réponses rapides",
+        "description": "Templates de réponses pré-enregistrées avec variables dynamiques"
+      },
+      "scheduledReplies": {
+        "label": "Réponses programmées",
+        "description": "Envoyer une réponse à une date/heure future"
+      },
+      "activityLog": {
+        "label": "Journal d'activité",
+        "description": "Timeline des actions sur chaque ticket (changements de statut, assignation...)"
+      },
+      "emailTracking": {
+        "label": "Suivi des emails",
+        "description": "Tracking d'envoi et d'ouverture des notifications email"
+      },
+      "chat": {
+        "label": "Live Chat",
+        "description": "Chat en temps réel avec conversion en ticket"
+      },
+      "externalMessages": {
+        "label": "Messages externes",
+        "description": "Ajouter manuellement des messages reçus par email, SMS, WhatsApp..."
+      },
+      "ai": {
+        "label": "Intelligence Artificielle",
+        "description": "Analyse de sentiment, synthèse, suggestion de réponse, reformulation"
+      },
+      "timeTracking": {
+        "label": "Suivi du temps",
+        "description": "Timer, entrées manuelles, facturation"
+      },
+      "satisfaction": {
+        "label": "Enquêtes satisfaction",
+        "description": "Score CSAT après résolution du ticket"
+      },
+      "merge": {
+        "label": "Fusion de tickets",
+        "description": "Combiner deux tickets en un seul"
+      },
+      "splitTicket": {
+        "label": "Extraction de message",
+        "description": "Extraire un message en nouveau ticket lié"
+      },
+      "snooze": {
+        "label": "Snooze",
+        "description": "Masquer temporairement un ticket et rappel automatique"
+      },
+      "clientHistory": {
+        "label": "Historique client",
+        "description": "Tickets passés, projets et notes internes du client"
+      }
     },
     "categories": {
       "core": "Fonctionnalités de base",

package/dist/views/shared/sla.d.ts

@@ -1,14 +1,33 @@
-export type SlaState = 'ok' | 'warn' | 'breach' | 'none' | 'met';
+export type SlaState = 'ok' | 'warn' | 'breach' | 'none' | 'met' | 'paused';
 export interface SlaInput {
     slaFirstResponseDue?: string | null;
     slaFirstResponseBreached?: boolean | null;
     firstResponseAt?: string | null;
     slaResolutionDue?: string | null;
     slaResolutionBreached?: boolean | null;
+    /** Set while the ticket sits in `waiting_client`; the resolution clock is stopped. */
+    slaPausedAt?: string | null;
 }
+/**
+ * How long the resolution clock has been stopped, in milliseconds, or 0.
+ *
+ * `createPauseSlaOnHold` only stamps `slaPausedAt` when the ticket enters
+ * `waiting_client`; it pushes `slaResolutionDue` forward *on the way out*, once
+ * it knows how long the pause lasted. So for the whole duration of the pause the
+ * stored deadline is stale by exactly this much, and anything comparing it to
+ * `now` — this function's callers included — reads a breach that the server does
+ * not consider one.
+ *
+ * Rather than wait for the resume hook, we add the elapsed pause back here. The
+ * arithmetic is the same the hook performs later, so the badge during the pause
+ * and the stored deadline after it agree.
+ */
+export declare function pausedForMs(t: SlaInput, now?: Date): number;
 export declare function computeSlaState(t: SlaInput, now?: Date): {
     state: SlaState;
     remainingMs: number | null;
     due: string | null;
+    /** Only set while paused: how long the clock has been stopped. */
+    pausedMs?: number;
 };
 export declare function formatSlaRemaining(remainingMs: number | null): string;

package/dist/views/shared/sla.js

@@ -1,5 +1,11 @@
 const HOUR_MS = 36e5;
 const MINUTE_MS = 6e4;
+function pausedForMs(t, now = /* @__PURE__ */ new Date()) {
+  if (!t.slaPausedAt) return 0;
+  const pausedAt = new Date(t.slaPausedAt);
+  if (Number.isNaN(pausedAt.getTime())) return 0;
+  return Math.max(0, now.getTime() - pausedAt.getTime());
+}
 function computeSlaState(t, now = /* @__PURE__ */ new Date()) {
   const hasFirstResponse = !!t.firstResponseAt;
   const dueRaw = hasFirstResponse ? t.slaResolutionDue : t.slaFirstResponseDue;
@@ -7,7 +13,12 @@ function computeSlaState(t, now = /* @__PURE__ */ new Date()) {
   if (!dueRaw) return { state: "none", remainingMs: null, due: null };
   const dueDate = new Date(dueRaw);
   if (Number.isNaN(dueDate.getTime())) return { state: "none", remainingMs: null, due: null };
-  const remaining = dueDate.getTime() - now.getTime();
+  const pausedMs = hasFirstResponse ? pausedForMs(t, now) : 0;
+  const remaining = dueDate.getTime() + pausedMs - now.getTime();
+  if (pausedMs > 0) {
+    if (breached) return { state: "breach", remainingMs: remaining, due: dueRaw, pausedMs };
+    return { state: "paused", remainingMs: remaining, due: dueRaw, pausedMs };
+  }
   if (breached || remaining < 0) {
     return { state: "breach", remainingMs: remaining, due: dueRaw };
   }
@@ -31,4 +42,4 @@ function formatSlaRemaining(remainingMs) {
   return `${sign}${d}j`;
 }
 
-export { computeSlaState, formatSlaRemaining };
+export { computeSlaState, formatSlaRemaining, pausedForMs };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@consilioweb/payload-support",
-  "version": "6.0.1",
+  "version": "6.0.3",
   "description": "Payload CMS plugin — professional support & ticketing system with AI, SLA, time tracking, live chat, and more",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -41,7 +41,8 @@
     }
   },
   "bin": {
-    "support-uninstall": "./scripts/uninstall.mjs"
+    "support-uninstall": "./scripts/uninstall.mjs",
+    "support-audit-sla": "./scripts/audit-sla-breaches.mjs"
   },
   "files": [
     "dist",

package/scripts/audit-sla-breaches.mjs

@@ -0,0 +1,175 @@
+#!/usr/bin/env node
+
+/**
+ * Data remediation for `slaResolutionBreached` flags written in error.
+ *
+ * NOT meant to be run directly: it is spawned through `payload run`, which puts
+ * the TypeScript loader and the environment in place so the host's
+ * `payload.config.ts` can be imported. See the usage banner at the bottom.
+ *
+ * WHY THIS EXISTS
+ * ---------------
+ * Until 6.0.2, resolving a ticket straight out of `waiting_client` could store a
+ * breach that never happened.
+ *
+ * `createPauseSlaOnHold` and `createCheckSlaOnResolve` are both `afterChange`
+ * hooks on tickets, registered in that order. When a paused ticket is resolved,
+ * the first pushes `slaResolutionDue` forward by the paused span and writes it
+ * to the database — but the `doc` handed to the second was captured before that
+ * write. It therefore compared `now` against the UN-extended deadline and wrote
+ * `slaResolutionBreached: true`.
+ *
+ * 6.0.2 closes the cause. It does not sweep what came through, and nothing else
+ * does either: the flag is `admin: { readOnly: true }`, so it cannot be cleared
+ * from the admin panel.
+ *
+ * HOW A FALSE FLAG IS IDENTIFIED — and why this is provable rather than guessed
+ * ---------------------------------------------------------------------------
+ * The pause hook DID write the extended deadline; only the sibling hook read a
+ * stale copy. So the row ends up carrying a CORRECT `slaResolutionDue` next to
+ * an INCORRECT `slaResolutionBreached`, and re-comparing the two settles it:
+ *
+ *     resolvedAt <= slaResolutionDue   →  the ticket met its SLA, flag is false
+ *     resolvedAt >  slaResolutionDue   →  it really did breach, flag is right
+ *
+ * A ticket that was never paused has an unmodified deadline, so the same
+ * comparison confirms its flag instead of clearing it. There is no window in
+ * which this test clears a genuine breach.
+ *
+ * WHAT IT CANNOT SEE
+ * ------------------
+ * If the resume hook itself failed — its body is wrapped in a `try`/`catch` that
+ * logs to `console.error` and swallows — the deadline was never extended, and
+ * the row looks exactly like an honest breach. Those are indistinguishable after
+ * the fact and are left alone. Check your server logs for
+ * `[sla] Failed to pause/resume SLA on hold` over the affected period.
+ *
+ * `slaFirstResponseBreached` is never touched: the pause stops the resolution
+ * clock only, so first-response flags were always computed correctly.
+ */
+
+import { getPayload } from 'payload'
+import { findConfig } from 'payload/node'
+import { pathToFileURL } from 'node:url'
+
+const args = process.argv.slice(2)
+const APPLY = args.includes('--fix')
+const slugArg = args.find((a) => a.startsWith('--tickets='))
+const TICKETS_SLUG = slugArg ? slugArg.slice('--tickets='.length) : 'tickets'
+
+const fmt = (d) => (d ? new Date(d).toISOString().replace('T', ' ').slice(0, 16) : '—')
+
+/** Minutes between two dates, signed, for a human-readable margin. */
+const minutesBetween = (a, b) => Math.round((new Date(a).getTime() - new Date(b).getTime()) / 60000)
+
+async function main() {
+  const config = await import(pathToFileURL(findConfig()).href).then((m) => m.default)
+  const payload = await getPayload({ config })
+
+  let rows
+  try {
+    const res = await payload.find({
+      collection: TICKETS_SLUG,
+      where: { slaResolutionBreached: { equals: true } },
+      limit: 0,
+      depth: 0,
+      overrideAccess: true,
+      select: {
+        ticketNumber: true,
+        status: true,
+        resolvedAt: true,
+        slaResolutionDue: true,
+        slaResolutionBreached: true,
+        slaPausedAt: true,
+      },
+    })
+    rows = res.docs
+  } catch (err) {
+    console.error(`\n  Could not read the '${TICKETS_SLUG}' collection: ${err.message}`)
+    console.error('  If your install renames it, pass --tickets=<slug>.\n')
+    process.exit(1)
+  }
+
+  console.log(`\n  ${rows.length} ticket(s) carry slaResolutionBreached = true.\n`)
+
+  const falseFlags = []
+  const confirmed = []
+  const undecidable = []
+
+  for (const t of rows) {
+    if (!t.slaResolutionDue) {
+      // No deadline to compare against — the flag predates the SLA policy or the
+      // field was cleared. Not ours to judge.
+      undecidable.push({ t, why: 'no slaResolutionDue to compare against' })
+      continue
+    }
+    if (!t.resolvedAt) {
+      // Still open. The resolve race cannot have produced this flag, so it came
+      // from somewhere we are not modelling — report, never touch.
+      undecidable.push({ t, why: `flagged but not resolved (status: ${t.status})` })
+      continue
+    }
+    const margin = minutesBetween(t.slaResolutionDue, t.resolvedAt)
+    if (margin >= 0) falseFlags.push({ t, margin })
+    else confirmed.push({ t, margin })
+  }
+
+  if (confirmed.length) {
+    console.log(`  ${confirmed.length} confirmed breach(es) — left untouched:`)
+    for (const { t, margin } of confirmed) {
+      console.log(`    ${t.ticketNumber}  resolved ${fmt(t.resolvedAt)}, ${-margin} min past its deadline`)
+    }
+    console.log('')
+  }
+
+  if (undecidable.length) {
+    console.log(`  ${undecidable.length} row(s) this script will not judge:`)
+    for (const { t, why } of undecidable) console.log(`    ${t.ticketNumber}  ${why}`)
+    console.log('')
+  }
+
+  if (!falseFlags.length) {
+    console.log('  No false breach found. Nothing to repair.\n')
+    return
+  }
+
+  console.log(`  ${falseFlags.length} FALSE breach(es) — resolved within the deadline:`)
+  for (const { t, margin } of falseFlags) {
+    console.log(
+      `    ${t.ticketNumber}  resolved ${fmt(t.resolvedAt)}, ` +
+        `deadline ${fmt(t.slaResolutionDue)} — ${margin} min to spare`,
+    )
+  }
+  console.log('')
+
+  if (!APPLY) {
+    console.log('  Read-only run. Re-run with --fix to clear these flags.\n')
+    return
+  }
+
+  let repaired = 0
+  for (const { t } of falseFlags) {
+    try {
+      await payload.update({
+        collection: TICKETS_SLUG,
+        id: t.id,
+        data: { slaResolutionBreached: false },
+        overrideAccess: true,
+        // The hooks on this collection react to a status change; this write
+        // changes none, but skipping them keeps the repair inert either way.
+        context: { skipSlaHooks: true },
+      })
+      repaired += 1
+    } catch (err) {
+      console.error(`    ${t.ticketNumber}: update failed — ${err.message}`)
+    }
+  }
+  console.log(`\n  Cleared ${repaired} of ${falseFlags.length} false flag(s).\n`)
+}
+
+main()
+  .then(() => process.exit(0))
+  .catch((err) => {
+    console.error('\n  audit-sla-breaches failed:', err)
+    process.exit(1)
+  })

package/src/endpoints/sla-check.ts

@@ -47,6 +47,7 @@ export function createSlaCheckEndpoint(slugs: CollectionSlugs): Endpoint {
             slaResolutionDue: true,
             slaFirstResponseBreached: true,
             slaResolutionBreached: true,
+            slaPausedAt: true,
             firstResponseAt: true,
             createdAt: true,
           },
@@ -85,9 +86,19 @@ export function createSlaCheckEndpoint(slugs: CollectionSlugs): Endpoint {
             }
           }
 
-          // Check resolution SLA
+          // Check resolution SLA.
+          //
+          // A ticket sitting in `waiting_client` has its resolution clock
+          // stopped, but `createPauseSlaOnHold` only pushes `slaResolutionDue`
+          // forward when the ticket LEAVES that status. During the pause the
+          // stored deadline is stale by exactly the elapsed pause, so comparing
+          // it to `now` reports a breach the server does not consider one — and
+          // this endpoint is what feeds the escalation mail.
           if (t.slaResolutionDue) {
-            const deadline = new Date(t.slaResolutionDue)
+            const pausedMs = t.slaPausedAt
+              ? Math.max(0, now.getTime() - new Date(t.slaPausedAt).getTime())
+              : 0
+            const deadline = new Date(new Date(t.slaResolutionDue).getTime() + pausedMs)
             if (now > deadline) {
               ticketData.breachTypes.push('resolution')
             } else {

package/src/hooks/checkSLA.ts

@@ -353,7 +353,20 @@ export function createCheckSlaOnResolve(slugs: CollectionSlugs, notificationSlug
     try {
       const { payload } = req
       const now = new Date()
-      const deadline = new Date(doc.slaResolutionDue as string)
+
+      // `createPauseSlaOnHold` is registered just before this hook and, when the
+      // ticket is resolved straight out of `waiting_client`, it pushes
+      // `slaResolutionDue` forward by the paused span. That write lands in the
+      // database, but the `doc` handed to THIS hook was captured before it — so
+      // reading `doc.slaResolutionDue` here compares against the un-extended
+      // deadline and persists a breach that never happened.
+      //
+      // Re-adding the pause locally gives the same deadline the sibling hook
+      // just wrote, without depending on hook ordering or on re-reading the row.
+      const pausedMs = doc.slaPausedAt
+        ? Math.max(0, now.getTime() - new Date(doc.slaPausedAt as string).getTime())
+        : 0
+      const deadline = new Date(new Date(doc.slaResolutionDue as string).getTime() + pausedMs)
       const breached = now > deadline
 
       await dbUpdate(payload, slugs.tickets, {

package/src/styles/TicketInbox.module.scss

@@ -286,6 +286,10 @@
 .slaOk     { color: var(--theme-elevation-400); }
 .slaWarn   { color: var(--theme-warning-500, #c97a0a); font-weight: 600; }
 .slaBreach { color: var(--theme-error-500, #c4392c); font-weight: 700; }
+// Paused: deliberately neutral and italic. The clock is stopped because the
+// team is waiting on the client, so this is not a state anyone should act on —
+// it must not compete with the warn and breach colours next to it.
+.slaPaused { color: var(--theme-elevation-650); font-style: italic; }
 
 .timeAgo {
   font-size: 12px;

package/src/views/TicketInboxView/client.tsx

@@ -26,6 +26,7 @@ interface Ticket {
   slaFirstResponseBreached?: boolean | null
   slaResolutionDue?: string | null
   slaResolutionBreached?: boolean | null
+  slaPausedAt?: string | null
   firstResponseAt?: string | null
 }
 
@@ -128,13 +129,21 @@ export const TicketInboxClient: React.FC = () => {
       `select[client]=true`, `select[updatedAt]=true`,
       `select[lastClientMessageAt]=true`, `select[lastAdminReadAt]=true`,
       `select[slaFirstResponseDue]=true`, `select[slaFirstResponseBreached]=true`,
-      `select[slaResolutionDue]=true`, `select[slaResolutionBreached]=true`,
+      `select[slaResolutionDue]=true`, `select[slaResolutionBreached]=true`, `select[slaPausedAt]=true`,
       `select[firstResponseAt]=true`,
     ]
     if (tab === 'sla_breach') {
-      // Either first-response breached or resolution breached
+      // Either first-response breached or resolution breached.
+      //
+      // A paused ticket is excluded. `createPauseSlaOnHold` stamps `slaPausedAt`
+      // on the way into `waiting_client` and only pushes `slaResolutionDue`
+      // forward on the way out, so during the pause the stored deadline is stale
+      // and this list would show a breach the server does not consider one.
+      // `computeSlaState` applies the same rule when it renders the row, so the
+      // tab and the badge cannot disagree.
       params.push(`where[or][0][slaFirstResponseBreached][equals]=true`)
       params.push(`where[or][1][slaResolutionBreached][equals]=true`)
+      params.push(`where[slaPausedAt][exists]=false`)
     } else if (tab !== 'all') {
       params.push(`where[status][equals]=${tab}`)
     }
@@ -178,7 +187,7 @@ export const TicketInboxClient: React.FC = () => {
           fetch(`/api/tickets/count?where[status][equals]=open&${sn}`, { credentials: 'include' }),
           fetch(`/api/tickets/count?where[status][equals]=waiting_client&${sn}`, { credentials: 'include' }),
           fetch(`/api/tickets/count?where[status][equals]=resolved&${sn}`, { credentials: 'include' }),
-          fetch(`/api/tickets/count?where[or][0][slaFirstResponseBreached][equals]=true&where[or][1][slaResolutionBreached][equals]=true&${sn}`, { credentials: 'include' }),
+          fetch(`/api/tickets/count?where[or][0][slaFirstResponseBreached][equals]=true&where[or][1][slaResolutionBreached][equals]=true&where[slaPausedAt][exists]=false&${sn}`, { credentials: 'include' }),
         ])
         const [a, o, w, r, b] = await Promise.all([all.json(), openRes.json(), waiting.json(), resolved.json(), breach.json()])
         setCounts({
@@ -350,6 +359,7 @@ export const TicketInboxClient: React.FC = () => {
             const priorityColor = PRIORITY_COLORS[tk.priority] || 'transparent'
             const sla = computeSlaState(tk)
             const isBreach = sla.state === 'breach'
+            const isPaused = sla.state === 'paused'
             const statusVariant: 'open' | 'pending' | 'resolved' | 'closed' = STATUS_VARIANT[tk.status] || 'open'
 
             return (
@@ -388,10 +398,15 @@ export const TicketInboxClient: React.FC = () => {
                     sla.state === 'breach' ? s.slaBreach : '',
                     sla.state === 'warn' ? s.slaWarn : '',
                     sla.state === 'ok' ? s.slaOk : '',
+                    isPaused ? s.slaPaused : '',
                   ].filter(Boolean).join(' ')}
-                  title={sla.due ? new Date(sla.due).toLocaleString(DATE_LOCALE) : ''}
+                  title={
+                    isPaused
+                      ? t('inbox.slaPausedTitle', { since: formatSlaRemaining(sla.pausedMs ?? 0) })
+                      : sla.due ? new Date(sla.due).toLocaleString(DATE_LOCALE) : ''
+                  }
                 >
-                  {formatSlaRemaining(sla.remainingMs)}
+                  {isPaused ? t('inbox.slaPaused') : formatSlaRemaining(sla.remainingMs)}
                 </span>
                 <span className={s.timeAgo}>{relativeTime(tk.updatedAt, t)}</span>
                 {isUnread ? <div className={s.unreadDot} /> : <span />}

package/src/views/shared/locales/en.json

@@ -348,7 +348,9 @@
       "responseAwaitedFor": "Awaiting for {{duration}}",
       "target": "Due: {{target}}",
       "escalate": "Escalate"
-    }
+    },
+    "slaPaused": "paused",
+    "slaPausedTitle": "SLA paused for {since} — the clock resumes when the client replies"
   },
   "emailTracking": {
     "title": "Email tracking",
@@ -695,19 +697,58 @@
     "saved2": "✓ Saved",
     "saveChanges": "Save changes",
     "features": {
-      "canned": { "label": "Quick replies", "description": "Pre-registered response templates with dynamic variables" },
-      "scheduledReplies": { "label": "Scheduled replies", "description": "Send a reply at a future date/time" },
-      "activityLog": { "label": "Activity log", "description": "Timeline of actions on each ticket (status changes, assignment...)" },
-      "emailTracking": { "label": "Email tracking", "description": "Send and open tracking for email notifications" },
-      "chat": { "label": "Live Chat", "description": "Real-time chat with ticket conversion" },
-      "externalMessages": { "label": "External messages", "description": "Manually add messages received by email, SMS, WhatsApp..." },
-      "ai": { "label": "Artificial Intelligence", "description": "Sentiment analysis, summary, reply suggestion, rewriting" },
-      "timeTracking": { "label": "Time tracking", "description": "Timer, manual entries, billing" },
-      "satisfaction": { "label": "Satisfaction surveys", "description": "CSAT score after ticket resolution" },
-      "merge": { "label": "Ticket merge", "description": "Combine two tickets into one" },
-      "splitTicket": { "label": "Message extraction", "description": "Extract a message into a new linked ticket" },
-      "snooze": { "label": "Snooze", "description": "Temporarily hide a ticket with automatic reminder" },
-      "clientHistory": { "label": "Client history", "description": "Past tickets, projects and internal notes" }
+      "canned": {
+        "label": "Quick replies",
+        "description": "Pre-registered response templates with dynamic variables"
+      },
+      "scheduledReplies": {
+        "label": "Scheduled replies",
+        "description": "Send a reply at a future date/time"
+      },
+      "activityLog": {
+        "label": "Activity log",
+        "description": "Timeline of actions on each ticket (status changes, assignment...)"
+      },
+      "emailTracking": {
+        "label": "Email tracking",
+        "description": "Send and open tracking for email notifications"
+      },
+      "chat": {
+        "label": "Live Chat",
+        "description": "Real-time chat with ticket conversion"
+      },
+      "externalMessages": {
+        "label": "External messages",
+        "description": "Manually add messages received by email, SMS, WhatsApp..."
+      },
+      "ai": {
+        "label": "Artificial Intelligence",
+        "description": "Sentiment analysis, summary, reply suggestion, rewriting"
+      },
+      "timeTracking": {
+        "label": "Time tracking",
+        "description": "Timer, manual entries, billing"
+      },
+      "satisfaction": {
+        "label": "Satisfaction surveys",
+        "description": "CSAT score after ticket resolution"
+      },
+      "merge": {
+        "label": "Ticket merge",
+        "description": "Combine two tickets into one"
+      },
+      "splitTicket": {
+        "label": "Message extraction",
+        "description": "Extract a message into a new linked ticket"
+      },
+      "snooze": {
+        "label": "Snooze",
+        "description": "Temporarily hide a ticket with automatic reminder"
+      },
+      "clientHistory": {
+        "label": "Client history",
+        "description": "Past tickets, projects and internal notes"
+      }
     },
     "categories": {
       "core": "Core features",

package/src/views/shared/locales/fr.json

@@ -348,7 +348,9 @@
       "responseAwaitedFor": "En attente depuis {{duration}}",
       "target": "Échéance : {{target}}",
       "escalate": "Escalader"
-    }
+    },
+    "slaPaused": "en pause",
+    "slaPausedTitle": "SLA en pause depuis {since} — le compteur repart à la réponse du client"
   },
   "emailTracking": {
     "title": "Suivi des emails",
@@ -695,19 +697,58 @@
     "saved2": "✓ Sauvegardé",
     "saveChanges": "Sauvegarder les modifications",
     "features": {
-      "canned": { "label": "Réponses rapides", "description": "Templates de réponses pré-enregistrées avec variables dynamiques" },
-      "scheduledReplies": { "label": "Réponses programmées", "description": "Envoyer une réponse à une date/heure future" },
-      "activityLog": { "label": "Journal d'activité", "description": "Timeline des actions sur chaque ticket (changements de statut, assignation...)" },
-      "emailTracking": { "label": "Suivi des emails", "description": "Tracking d'envoi et d'ouverture des notifications email" },
-      "chat": { "label": "Live Chat", "description": "Chat en temps réel avec conversion en ticket" },
-      "externalMessages": { "label": "Messages externes", "description": "Ajouter manuellement des messages reçus par email, SMS, WhatsApp..." },
-      "ai": { "label": "Intelligence Artificielle", "description": "Analyse de sentiment, synthèse, suggestion de réponse, reformulation" },
-      "timeTracking": { "label": "Suivi du temps", "description": "Timer, entrées manuelles, facturation" },
-      "satisfaction": { "label": "Enquêtes satisfaction", "description": "Score CSAT après résolution du ticket" },
-      "merge": { "label": "Fusion de tickets", "description": "Combiner deux tickets en un seul" },
-      "splitTicket": { "label": "Extraction de message", "description": "Extraire un message en nouveau ticket lié" },
-      "snooze": { "label": "Snooze", "description": "Masquer temporairement un ticket et rappel automatique" },
-      "clientHistory": { "label": "Historique client", "description": "Tickets passés, projets et notes internes du client" }
+      "canned": {
+        "label": "Réponses rapides",
+        "description": "Templates de réponses pré-enregistrées avec variables dynamiques"
+      },
+      "scheduledReplies": {
+        "label": "Réponses programmées",
+        "description": "Envoyer une réponse à une date/heure future"
+      },
+      "activityLog": {
+        "label": "Journal d'activité",
+        "description": "Timeline des actions sur chaque ticket (changements de statut, assignation...)"
+      },
+      "emailTracking": {
+        "label": "Suivi des emails",
+        "description": "Tracking d'envoi et d'ouverture des notifications email"
+      },
+      "chat": {
+        "label": "Live Chat",
+        "description": "Chat en temps réel avec conversion en ticket"
+      },
+      "externalMessages": {
+        "label": "Messages externes",
+        "description": "Ajouter manuellement des messages reçus par email, SMS, WhatsApp..."
+      },
+      "ai": {
+        "label": "Intelligence Artificielle",
+        "description": "Analyse de sentiment, synthèse, suggestion de réponse, reformulation"
+      },
+      "timeTracking": {
+        "label": "Suivi du temps",
+        "description": "Timer, entrées manuelles, facturation"
+      },
+      "satisfaction": {
+        "label": "Enquêtes satisfaction",
+        "description": "Score CSAT après résolution du ticket"
+      },
+      "merge": {
+        "label": "Fusion de tickets",
+        "description": "Combiner deux tickets en un seul"
+      },
+      "splitTicket": {
+        "label": "Extraction de message",
+        "description": "Extraire un message en nouveau ticket lié"
+      },
+      "snooze": {
+        "label": "Snooze",
+        "description": "Masquer temporairement un ticket et rappel automatique"
+      },
+      "clientHistory": {
+        "label": "Historique client",
+        "description": "Tickets passés, projets et notes internes du client"
+      }
     },
     "categories": {
       "core": "Fonctionnalités de base",

package/src/views/shared/sla.ts

@@ -1,7 +1,7 @@
 // SLA helpers — derive remaining time + visual state from ticket's
 // slaFirstResponseDue / slaFirstResponseBreached fields (already on Tickets).
 
-export type SlaState = 'ok' | 'warn' | 'breach' | 'none' | 'met'
+export type SlaState = 'ok' | 'warn' | 'breach' | 'none' | 'met' | 'paused'
 
 export interface SlaInput {
   slaFirstResponseDue?: string | null
@@ -9,15 +9,40 @@ export interface SlaInput {
   firstResponseAt?: string | null
   slaResolutionDue?: string | null
   slaResolutionBreached?: boolean | null
+  /** Set while the ticket sits in `waiting_client`; the resolution clock is stopped. */
+  slaPausedAt?: string | null
 }
 
 const HOUR_MS = 3_600_000
 const MINUTE_MS = 60_000
 
+/**
+ * How long the resolution clock has been stopped, in milliseconds, or 0.
+ *
+ * `createPauseSlaOnHold` only stamps `slaPausedAt` when the ticket enters
+ * `waiting_client`; it pushes `slaResolutionDue` forward *on the way out*, once
+ * it knows how long the pause lasted. So for the whole duration of the pause the
+ * stored deadline is stale by exactly this much, and anything comparing it to
+ * `now` — this function's callers included — reads a breach that the server does
+ * not consider one.
+ *
+ * Rather than wait for the resume hook, we add the elapsed pause back here. The
+ * arithmetic is the same the hook performs later, so the badge during the pause
+ * and the stored deadline after it agree.
+ */
+export function pausedForMs(t: SlaInput, now: Date = new Date()): number {
+  if (!t.slaPausedAt) return 0
+  const pausedAt = new Date(t.slaPausedAt)
+  if (Number.isNaN(pausedAt.getTime())) return 0
+  return Math.max(0, now.getTime() - pausedAt.getTime())
+}
+
 export function computeSlaState(t: SlaInput, now: Date = new Date()): {
   state: SlaState
   remainingMs: number | null
   due: string | null
+  /** Only set while paused: how long the clock has been stopped. */
+  pausedMs?: number
 } {
   // Once first-response is met, fall back to resolution SLA.
   const hasFirstResponse = !!t.firstResponseAt
@@ -29,7 +54,18 @@ export function computeSlaState(t: SlaInput, now: Date = new Date()): {
   const dueDate = new Date(dueRaw)
   if (Number.isNaN(dueDate.getTime())) return { state: 'none', remainingMs: null, due: null }
 
-  const remaining = dueDate.getTime() - now.getTime()
+  // The pause only stops the RESOLUTION clock. A first-response SLA keeps
+  // running while the client is being waited on — the agent has still not
+  // answered, which is precisely what that target measures.
+  const pausedMs = hasFirstResponse ? pausedForMs(t, now) : 0
+  const remaining = dueDate.getTime() + pausedMs - now.getTime()
+
+  if (pausedMs > 0) {
+    // A stored breach flag is not overridden: if the clock had already run out
+    // before the client was asked, the ticket really did breach.
+    if (breached) return { state: 'breach', remainingMs: remaining, due: dueRaw, pausedMs }
+    return { state: 'paused', remainingMs: remaining, due: dueRaw, pausedMs }
+  }
 
   if (breached || remaining < 0) {
     return { state: 'breach', remainingMs: remaining, due: dueRaw }