@consilioweb/payload-support 0.9.11 → 0.9.13

package/src/collections/Tickets.ts

@@ -13,6 +13,7 @@ import { dispatchWebhook } from '../utils/webhookDispatcher'
 import { readSupportSettings } from '../utils/readSettings'
 import { createTicketStatusEmail } from '../hooks/ticketStatusEmail'
 import { createAssignSlaDeadlines, createCheckSlaOnResolve } from '../hooks/checkSLA'
+import { generateTicketSynthesis } from '../utils/generateTicketSynthesis'
 
 // ─── Hooks ───────────────────────────────────────────────
 
@@ -154,6 +155,40 @@ function createTrackSLA(slugs: CollectionSlugs): CollectionAfterChangeHook {
   }
 }
 
+function createTrackAiSummaryOnResolve(slugs: CollectionSlugs): CollectionAfterChangeHook {
+  return async ({ doc, previousDoc, operation, req }) => {
+    if (operation !== 'update' || !previousDoc) return doc
+    const wasResolved = previousDoc.status === 'resolved'
+    const isResolved = doc.status === 'resolved'
+
+    // Reopening: clear the cached summary so the next resolve regenerates it
+    if (wasResolved && !isResolved && doc.aiSummary) {
+      try {
+        await req.payload.update({
+          collection: slugs.tickets,
+          id: doc.id,
+          data: { aiSummary: null, aiSummaryGeneratedAt: null, aiSummaryStatus: null },
+          overrideAccess: true,
+        })
+      } catch (err) {
+        console.error('[support] Failed to clear ai summary on reopen:', err)
+      }
+      return doc
+    }
+
+    // Just resolved: trigger generation if not already cached.
+    // Fire-and-forget so the admin UI doesn't block on the LLM call.
+    if (!wasResolved && isResolved && !doc.aiSummary) {
+      // setImmediate keeps the response snappy; failures are logged inside the util.
+      setImmediate(() => {
+        generateTicketSynthesis({ payload: req.payload, slugs, ticketId: doc.id })
+          .catch((err) => console.error('[support] Background ai synthesis failed:', err))
+      })
+    }
+    return doc
+  }
+}
+
 function createLogTicketActivity(slugs: CollectionSlugs): CollectionAfterChangeHook {
   return async ({ doc, previousDoc, operation, req }) => {
     if (operation !== 'update' || !previousDoc) return doc
@@ -596,6 +631,48 @@ export function createTicketsCollection(slugs: CollectionSlugs, options?: {
         admin: { initCollapsed: true },
         fields: billingFields,
       },
+      // AI Synthesis collapsible — auto-filled when ticket is resolved
+      {
+        type: 'collapsible', label: 'Synthese IA',
+        admin: {
+          initCollapsed: true,
+          description: 'Recap factuel genere automatiquement au passage en resolu. Sert au copier-coller dans devis/factures.',
+        },
+        fields: [
+          {
+            name: 'aiSummary',
+            type: 'textarea',
+            label: 'Synthese',
+            admin: {
+              readOnly: true,
+              rows: 8,
+              description: 'Vide tant que le ticket n\'est pas resolu. Effacee si le ticket est reouvert.',
+            },
+          },
+          {
+            type: 'row',
+            fields: [
+              {
+                name: 'aiSummaryGeneratedAt',
+                type: 'date',
+                label: 'Genere le',
+                admin: { readOnly: true, width: '50%', date: { displayFormat: 'dd/MM/yyyy HH:mm' } },
+              },
+              {
+                name: 'aiSummaryStatus',
+                type: 'select',
+                label: 'Statut',
+                options: [
+                  { label: 'En cours', value: 'pending' },
+                  { label: 'Genere', value: 'done' },
+                  { label: 'Erreur', value: 'error' },
+                ],
+                admin: { readOnly: true, width: '50%' },
+              },
+            ],
+          },
+        ],
+      },
       // SLA & Delais
       {
         type: 'collapsible', label: 'SLA & Delais',
@@ -710,6 +787,7 @@ export function createTicketsCollection(slugs: CollectionSlugs, options?: {
       ],
       afterChange: [
         createTrackSLA(slugs),
+        createTrackAiSummaryOnResolve(slugs),
         createAutoCalculateSLA(slugs),
         createAssignSlaDeadlines(slugs, notificationSlug),
         createCheckSlaOnResolve(slugs, notificationSlug),

package/src/endpoints/billing.ts

@@ -8,6 +8,10 @@ const MAX_PAGES = 50
 /**
  * GET /api/support/billing?from=...&to=...&projectId=...
  * Admin-only endpoint returning billing data.
+ *
+ * Includes ALL billable tickets active during the period (i.e. updated/created/resolved
+ * between from and to) — even those without any time entries, so the admin can spot
+ * tickets where time was forgotten.
  */
 export function createBillingEndpoint(slugs: CollectionSlugs): Endpoint {
   return {
@@ -29,12 +33,43 @@ export function createBillingEndpoint(slugs: CollectionSlugs): Endpoint {
 
         const projectId = url.searchParams.get('projectId')
 
+        // Build an exclusive upper-bound for ISO datetime fields:
+        // when filtering on updatedAt / resolvedAt with `to=2026-04-30`, we want to include
+        // events that happened on April 30 after 00:00.
+        const toExclusive = new Date(to)
+        toExclusive.setDate(toExclusive.getDate() + 1)
+        const toExclusiveIso = toExclusive.toISOString()
+
         const ticketWhere: Where = {
-          billable: { equals: true },
-          ...(projectId ? { project: { equals: Number(projectId) } } : {}),
+          and: [
+            { billable: { equals: true } },
+            ...(projectId ? [{ project: { equals: Number(projectId) } } as Where] : []),
+            {
+              or: [
+                {
+                  and: [
+                    { updatedAt: { greater_than_equal: from } },
+                    { updatedAt: { less_than: toExclusiveIso } },
+                  ],
+                },
+                {
+                  and: [
+                    { createdAt: { greater_than_equal: from } },
+                    { createdAt: { less_than: toExclusiveIso } },
+                  ],
+                },
+                {
+                  and: [
+                    { resolvedAt: { greater_than_equal: from } },
+                    { resolvedAt: { less_than: toExclusiveIso } },
+                  ],
+                },
+              ],
+            },
+          ],
         }
 
-        // Paginate tickets instead of limit:0
+        // Paginate tickets
         const allTickets: Array<Record<string, unknown>> = []
         let ticketPage = 1
         let ticketHasMore = true
@@ -53,7 +88,7 @@ export function createBillingEndpoint(slugs: CollectionSlugs): Endpoint {
           ticketPage++
         }
 
-        // Paginate time entries instead of limit:0
+        // Paginate time entries within the period
         const allEntries: Array<Record<string, unknown>> = []
         let entryPage = 1
         let entryHasMore = true
@@ -94,15 +129,27 @@ export function createBillingEndpoint(slugs: CollectionSlugs): Endpoint {
         const projectGroups = new Map<string, {
           project: { id: number; name: string } | null
           client: { company: string } | null
-          tickets: Array<{ id: number; ticketNumber: string; subject: string; entries: any[]; totalMinutes: number; billedAmount: number | null }>
+          tickets: Array<{
+            id: number
+            ticketNumber: string
+            subject: string
+            status: string
+            entries: Array<{ duration: number; description: string; date: string }>
+            totalMinutes: number
+            billedAmount: number | null
+            hasNoTimeEntries: boolean
+            aiSummary: string | null
+            aiSummaryGeneratedAt: string | null
+            aiSummaryStatus: string | null
+          }>
           totalMinutes: number
           totalBilledAmount: number
         }>()
 
         for (const ticket of allTickets) {
           const t = ticket as any
-          const ticketEntries = entriesByTicket.get(t.id)
-          if (!ticketEntries || ticketEntries.length === 0) continue
+          const ticketEntries = entriesByTicket.get(t.id) || []
+          const hasNoTimeEntries = ticketEntries.length === 0
 
           const project = typeof t.project === 'object' && t.project
             ? { id: t.project.id, name: t.project.name || 'Sans nom' }
@@ -138,9 +185,14 @@ export function createBillingEndpoint(slugs: CollectionSlugs): Endpoint {
             id: t.id,
             ticketNumber: t.ticketNumber || '',
             subject: t.subject || '',
+            status: t.status || '',
             entries: ticketEntries,
             totalMinutes: ticketTotalMinutes,
             billedAmount,
+            hasNoTimeEntries,
+            aiSummary: t.aiSummary || null,
+            aiSummaryGeneratedAt: t.aiSummaryGeneratedAt || null,
+            aiSummaryStatus: t.aiSummaryStatus || null,
           })
           projectGroups.get(projectKey)!.totalMinutes += ticketTotalMinutes
           if (billedAmount) projectGroups.get(projectKey)!.totalBilledAmount += billedAmount
@@ -149,8 +201,17 @@ export function createBillingEndpoint(slugs: CollectionSlugs): Endpoint {
         const groups = Array.from(projectGroups.values())
         const grandTotalMinutes = groups.reduce((sum, g) => sum + g.totalMinutes, 0)
         const grandTotalBilledAmount = groups.reduce((sum, g) => sum + g.totalBilledAmount, 0)
-
-        return new Response(JSON.stringify({ groups, grandTotalMinutes, grandTotalBilledAmount }), {
+        const ticketsWithoutTime = groups.reduce(
+          (sum, g) => sum + g.tickets.filter((t) => t.hasNoTimeEntries).length,
+          0,
+        )
+
+        return new Response(JSON.stringify({
+          groups,
+          grandTotalMinutes,
+          grandTotalBilledAmount,
+          ticketsWithoutTime,
+        }), {
           headers: {
             'Content-Type': 'application/json',
             'Cache-Control': 'private, max-age=300, stale-while-revalidate=600',

package/src/endpoints/index.ts

@@ -25,6 +25,7 @@ import { createAdminChatGetEndpoint, createAdminChatPostEndpoint } from './admin
 import { createAdminChatStreamEndpoint } from './admin-chat-stream'
 import { createAdminStatsEndpoint } from './admin-stats'
 import { createBillingEndpoint } from './billing'
+import { createTicketSynthesisEndpoint } from './ticket-synthesis'
 import { createEmailStatsEndpoint } from './email-stats'
 import { createSatisfactionEndpoint } from './satisfaction'
 import { createTrackOpenEndpoint } from './track-open'
@@ -65,6 +66,7 @@ export { createAdminChatGetEndpoint, createAdminChatPostEndpoint } from './admin
 export { createAdminChatStreamEndpoint } from './admin-chat-stream'
 export { createAdminStatsEndpoint } from './admin-stats'
 export { createBillingEndpoint } from './billing'
+export { createTicketSynthesisEndpoint } from './ticket-synthesis'
 export { createEmailStatsEndpoint } from './email-stats'
 export { createSatisfactionEndpoint } from './satisfaction'
 export { createTrackOpenEndpoint } from './track-open'
@@ -121,6 +123,7 @@ export function createSupportEndpoints(slugs: CollectionSlugs, options?: Support
   if (!f || f.ai !== false) {
     endpoints.push(createAiEndpoint(slugs))
     endpoints.push(...createClientIntelligenceEndpoint(slugs))
+    endpoints.push(createTicketSynthesisEndpoint(slugs))
   }
   if (!f || f.bulkActions !== false) endpoints.push(createBulkActionEndpoint(slugs))
   if (!f || f.merge !== false) endpoints.push(createMergeTicketsEndpoint(slugs))

package/src/endpoints/ticket-synthesis.ts

@@ -0,0 +1,67 @@
+import type { Endpoint } from 'payload'
+import type { CollectionSlugs } from '../utils/slugs'
+import { requireAdmin, handleAuthError } from '../utils/auth'
+import { generateTicketSynthesis } from '../utils/generateTicketSynthesis'
+
+/**
+ * POST /api/support/ticket-synthesis?ticketId=X[&force=true]
+ *
+ * Admin-only. Generates (or returns the cached) AI bullet-point synthesis for a single ticket.
+ * The synthesis is persisted on the ticket itself (aiSummary, aiSummaryGeneratedAt, aiSummaryStatus).
+ *
+ * Cache behaviour:
+ * - If aiSummary already exists and force is not set, returns the cached value (status: cached).
+ * - If force=true, regenerates regardless of existing summary.
+ * - The hook on Tickets clears aiSummary when a ticket is reopened, so the next pass through
+ *   "resolved" status will trigger a regeneration automatically.
+ */
+export function createTicketSynthesisEndpoint(slugs: CollectionSlugs): Endpoint {
+  return {
+    path: '/support/ticket-synthesis',
+    method: 'post',
+    handler: async (req) => {
+      try {
+        requireAdmin(req, slugs)
+        const payload = req.payload
+
+        const url = new URL(req.url || '', 'http://localhost')
+        const ticketIdRaw = url.searchParams.get('ticketId')
+        const force = url.searchParams.get('force') === 'true'
+
+        if (!ticketIdRaw) {
+          return Response.json({ error: 'ticketId required' }, { status: 400 })
+        }
+
+        const ticketId = Number(ticketIdRaw)
+        if (Number.isNaN(ticketId)) {
+          return Response.json({ error: 'ticketId must be a number' }, { status: 400 })
+        }
+
+        if (!force) {
+          const existing = await payload.findByID({
+            collection: slugs.tickets as any,
+            id: ticketId,
+            depth: 0,
+            overrideAccess: true,
+          }) as { aiSummary?: string; aiSummaryGeneratedAt?: string; aiSummaryStatus?: string } | null
+
+          if (existing?.aiSummary && existing.aiSummaryStatus === 'done') {
+            return Response.json({
+              summary: existing.aiSummary,
+              generatedAt: existing.aiSummaryGeneratedAt,
+              status: 'cached',
+            })
+          }
+        }
+
+        const result = await generateTicketSynthesis({ payload, slugs, ticketId })
+        return Response.json(result)
+      } catch (err) {
+        const authResponse = handleAuthError(err)
+        if (authResponse) return authResponse
+        console.error('[support/ticket-synthesis] Error:', err)
+        return Response.json({ error: 'Internal server error' }, { status: 500 })
+      }
+    },
+  }
+}

package/src/index.ts

@@ -25,6 +25,8 @@ export { readSupportSettings, readUserPrefs, DEFAULT_SETTINGS, DEFAULT_USER_PREF
 export type { SupportSettings, UserPrefs } from './utils/readSettings'
 export { createAdminNotification } from './utils/adminNotification'
 export { dispatchWebhook } from './utils/webhookDispatcher'
+export { generateTicketSynthesis } from './utils/generateTicketSynthesis'
+export type { TicketSynthesisResult } from './utils/generateTicketSynthesis'
 
 // Hooks
 export { createAssignSlaDeadlines, createCheckSlaOnResolve, createCheckSlaOnReply, calculateBusinessHoursDeadline } from './hooks/checkSLA'

package/src/styles/BillingView.module.scss

@@ -276,6 +276,138 @@
   color: #16a34a;
 }
 
+// Warning banner — tickets without time
+.warningBanner {
+  padding: 10px 16px;
+  border: 1px solid #f59e0b;
+  border-radius: 8px;
+  background: rgba(245, 158, 11, 0.08);
+  margin-bottom: 16px;
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  flex-wrap: wrap;
+  gap: 12px;
+  font-size: 13px;
+  color: var(--theme-text);
+}
+
+.toggleLabel {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  cursor: pointer;
+  font-weight: 600;
+  user-select: none;
+}
+
+.noTimeBadge {
+  display: inline-block;
+  margin-left: 8px;
+  padding: 2px 8px;
+  border-radius: 999px;
+  background: rgba(245, 158, 11, 0.15);
+  color: #b45309;
+  font-size: 11px;
+  font-weight: 700;
+  white-space: nowrap;
+}
+
+.tableRowNoTime {
+  border-bottom: 1px solid var(--theme-elevation-200);
+  background: rgba(245, 158, 11, 0.04);
+}
+
+// AI summary toggle button
+.summaryBtn {
+  display: inline-block;
+  margin-left: 6px;
+  padding: 1px 6px;
+  border-radius: 4px;
+  border: 1px solid var(--theme-elevation-300);
+  background: var(--theme-elevation-100);
+  color: var(--theme-elevation-500);
+  font-size: 10px;
+  font-weight: 600;
+  cursor: pointer;
+  vertical-align: middle;
+  transition: background-color 100ms, color 100ms;
+
+  &:hover {
+    background: #2563eb;
+    color: #fff;
+    border-color: #2563eb;
+  }
+}
+
+// AI summary expanded row
+.summaryRow {
+  background: var(--theme-elevation-50);
+  border-bottom: 1px solid var(--theme-elevation-300);
+}
+
+.summaryCell {
+  padding: 12px 16px 16px;
+}
+
+.summaryHeader {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  margin-bottom: 8px;
+  flex-wrap: wrap;
+  gap: 8px;
+}
+
+.summaryActions {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+
+.summaryMeta {
+  font-size: 11px;
+  color: var(--theme-elevation-500);
+}
+
+.summaryAction {
+  padding: 4px 10px;
+  border-radius: 6px;
+  border: 1px solid var(--theme-elevation-300);
+  background: var(--theme-elevation-100);
+  color: var(--theme-text);
+  font-size: 12px;
+  font-weight: 600;
+  cursor: pointer;
+  transition: background-color 100ms;
+
+  &:hover { background: var(--theme-elevation-200); }
+  &:disabled { cursor: not-allowed; opacity: 0.5; }
+}
+
+.summaryText {
+  margin: 0;
+  padding: 10px 12px;
+  background: var(--theme-elevation-100);
+  border: 1px solid var(--theme-elevation-300);
+  border-radius: 6px;
+  font-family: -apple-system, BlinkMacSystemFont, 'Inter', system-ui, sans-serif;
+  font-size: 13px;
+  color: var(--theme-text);
+  white-space: pre-wrap;
+  word-break: break-word;
+}
+
+.summaryEmpty {
+  padding: 10px 12px;
+  background: var(--theme-elevation-100);
+  border: 1px dashed var(--theme-elevation-300);
+  border-radius: 6px;
+  color: var(--theme-elevation-500);
+  font-size: 12px;
+  font-style: italic;
+}
+
 // Grand total
 .grandTotal {
   padding: 16px;

package/src/utils/generateTicketSynthesis.ts

@@ -0,0 +1,178 @@
+import type { Payload } from 'payload'
+import type { CollectionSlugs } from './slugs'
+import { readSupportSettings, type SupportSettings } from './readSettings'
+
+function getClient(aiSettings: SupportSettings['ai']) {
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  const Anthropic = require('@anthropic-ai/sdk').default
+  if (aiSettings.provider === 'ollama') {
+    const baseURL = process.env.OLLAMA_API_URL || 'https://ollama.orkelis.app/v1'
+    return new Anthropic({ apiKey: 'ollama', baseURL })
+  }
+  return new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY })
+}
+
+function getModel(aiSettings: SupportSettings['ai']): string {
+  return aiSettings.model || 'claude-haiku-4-5-20251001'
+}
+
+interface TicketMessageDoc {
+  authorType?: string
+  body?: string
+  createdAt?: string
+}
+
+interface TicketDoc {
+  id: number | string
+  subject?: string
+  ticketNumber?: string
+  client?: number | { id: number; firstName?: string; lastName?: string; company?: string } | null
+}
+
+export interface TicketSynthesisResult {
+  summary: string
+  generatedAt: string
+  status: 'done' | 'error' | 'skipped'
+  reason?: string
+}
+
+/**
+ * Generates a billing-oriented bullet-point synthesis for a single support ticket.
+ * Persists the result on the ticket (aiSummary, aiSummaryGeneratedAt, aiSummaryStatus).
+ * Designed to be called from an HTTP endpoint OR from a Payload hook (async fire-and-forget).
+ */
+export async function generateTicketSynthesis(args: {
+  payload: Payload
+  slugs: CollectionSlugs
+  ticketId: number | string
+}): Promise<TicketSynthesisResult> {
+  const { payload, slugs, ticketId } = args
+
+  const settings = await readSupportSettings(payload)
+  if (settings.ai.enableSynthesis === false) {
+    return { summary: '', generatedAt: new Date().toISOString(), status: 'skipped', reason: 'synthesis disabled' }
+  }
+
+  const ticket = await payload.findByID({
+    collection: slugs.tickets as any,
+    id: ticketId,
+    depth: 1,
+    overrideAccess: true,
+  }) as TicketDoc
+
+  if (!ticket) {
+    return { summary: '', generatedAt: new Date().toISOString(), status: 'error', reason: 'ticket not found' }
+  }
+
+  // Mark as pending so the UI can show a spinner
+  await payload.update({
+    collection: slugs.tickets as any,
+    id: ticketId,
+    data: { aiSummaryStatus: 'pending' },
+    overrideAccess: true,
+  }).catch(() => { /* non-blocking */ })
+
+  // Load all ticket messages, ordered chronologically
+  const messagesResult = await payload.find({
+    collection: slugs.ticketMessages as any,
+    where: { ticket: { equals: ticketId } },
+    sort: 'createdAt',
+    limit: 500,
+    depth: 0,
+    overrideAccess: true,
+  })
+
+  const messages = messagesResult.docs as TicketMessageDoc[]
+
+  if (messages.length === 0) {
+    const generatedAt = new Date().toISOString()
+    await payload.update({
+      collection: slugs.tickets as any,
+      id: ticketId,
+      data: {
+        aiSummary: '(Aucun message dans ce ticket)',
+        aiSummaryGeneratedAt: generatedAt,
+        aiSummaryStatus: 'done',
+      },
+      overrideAccess: true,
+    })
+    return { summary: '(Aucun message dans ce ticket)', generatedAt, status: 'done' }
+  }
+
+  const conversation = messages
+    .map((m) => {
+      const author = m.authorType === 'admin' ? 'Support' : 'Client'
+      const date = m.createdAt
+        ? new Date(m.createdAt).toLocaleDateString('fr-FR', {
+            day: 'numeric',
+            month: 'short',
+            hour: '2-digit',
+            minute: '2-digit',
+            timeZone: 'Europe/Paris',
+          })
+        : ''
+      return `[${date}] ${author}: ${m.body || ''}`
+    })
+    .join('\n\n')
+
+  const clientObj = typeof ticket.client === 'object' && ticket.client ? ticket.client : null
+  const clientCompany = clientObj?.company || ''
+  const clientName = clientObj ? [clientObj.firstName, clientObj.lastName].filter(Boolean).join(' ') : ''
+
+  const prompt = `Tu es un consultant technique qui prepare un recap factuel pour une facturation client.
+
+Sujet du ticket : ${ticket.subject || '(sans sujet)'}
+Client : ${clientName || 'Inconnu'}${clientCompany ? ` — ${clientCompany}` : ''}
+
+Conversation complete du ticket :
+${conversation}
+
+Genere un recap factuel sous forme d'une liste a puces courtes et actionnables, decrivant CE QUI A ETE FAIT cote support pendant ce ticket. C'est destine a etre colle dans un devis ou une facture.
+
+Regles strictes :
+- Une puce = une action realisee, formulee en groupe nominal court (ex : "Diagnostic configuration DNS et authentification Mailchimp")
+- Pas de phrases completes, pas de "j'ai fait", pas de pronoms
+- Pas de salutations, pas d'introduction, pas de conclusion
+- Pas de markdown autre que les puces "- "
+- 5 a 10 puces maximum, ordonnees chronologiquement
+- Ne mentionne PAS le client par son nom dans les puces
+- Si le ticket n'a pas abouti, decris quand meme le travail d'analyse realise
+
+Reponds UNIQUEMENT avec la liste de puces, rien d'autre.`
+
+  const anthropic = getClient(settings.ai)
+  const model = getModel(settings.ai)
+
+  try {
+    const res = await anthropic.messages.create({
+      model,
+      max_tokens: 600,
+      messages: [{ role: 'user', content: prompt }],
+    })
+
+    const summary = res.content[0]?.type === 'text' ? res.content[0].text.trim() : ''
+    const generatedAt = new Date().toISOString()
+
+    await payload.update({
+      collection: slugs.tickets as any,
+      id: ticketId,
+      data: {
+        aiSummary: summary,
+        aiSummaryGeneratedAt: generatedAt,
+        aiSummaryStatus: 'done',
+      },
+      overrideAccess: true,
+    })
+
+    return { summary, generatedAt, status: 'done' }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err)
+    await payload.update({
+      collection: slugs.tickets as any,
+      id: ticketId,
+      data: { aiSummaryStatus: 'error' },
+      overrideAccess: true,
+    }).catch(() => { /* non-blocking */ })
+    return { summary: '', generatedAt: new Date().toISOString(), status: 'error', reason: message }
+  }
+}