wldx-cli 0.1.1 → 1.1.0

package/src/live/stats.mjs

@@ -0,0 +1,243 @@
+// Queue statistics of the live stream of Wildix Data Analytics (WDA): the subscribe options that ask for them and
+// the figures derived from the raw counters. Pure functions, no I/O (ported unchanged from the stats.mjs of the
+// wildix-live-monitor skill, which its dashboard shares).
+//
+// The services topic sends counters, never rates: with stats asked for, every service of the subscribe snapshot
+// carries `stats`, and later changes come as `service_stats_update` events (at most one per 5 seconds per queue,
+// and at each 15-minute bucket roll-over). Counters of a window are added when a call progresses: offered when it
+// enters the queue, answered when it is answered, the rest (abandoned, unanswered, talk, wrap-up) when it ends.
+
+export const SLA_SECONDS = [5, 10, 15, 20, 25, 30];
+export const WINDOWS = ['today', '15', '30', '45', '60'];
+
+const round = (n, d = 0) =>
+  n === null || n === undefined || !Number.isFinite(n) ? null : Math.round(n * 10 ** d) / 10 ** d;
+const ratio = (a, b) => (b ? a / b : null);
+const pct = (a, b) => round(b ? (a / b) * 100 : null, 1);
+const sec = (ms) => round(ms === null || ms === undefined ? null : ms / 1000);
+const min = (ms) => round(ms === null || ms === undefined ? null : ms / 60000, 1);
+const iso = (ms) => (typeof ms === 'number' ? new Date(ms).toISOString() : undefined);
+
+// The subscribe options of a stats window: `today` from the local midnight (WDA keeps hourly UTC buckets, so the
+// day must start on a whole UTC hour: in a zone with a half-hour offset the window starts at the UTC hour before
+// the local midnight), or the last 15, 30, 45 or 60 minutes. sla: the answer-within target, one of SLA_SECONDS.
+export function statsOptions(window = 'today', sla = 20, now = Date.now()) {
+  const base = {stats: true, serviceLevelSeconds: sla};
+  if (window !== 'today') return {...base, periodMinutes: Number(window)};
+  const offset = -new Date(now).getTimezoneOffset();
+  if (offset % 60 === 0) return {...base, periodStart: 'today', utcOffsetMinutes: offset};
+  const midnight = new Date(now);
+  midnight.setHours(0, 0, 0, 0);
+  return {...base, periodStartAt: Math.floor(midnight.getTime() / 3600000) * 3600000};
+}
+
+// The figures of one queue's stats (or of the sum of several, see sumStats). Rates follow the definitions of the
+// service: service level = answeredWithinSl / (answered + abandoned - shortAbandoned + unanswered), short abandons
+// (within 5 s, likely misdials) left out of the base; ASA = answeredWaitSumMs / answered.
+export function queueFigures(s, now = Date.now()) {
+  if (!s) return undefined;
+  const base = s.answered + (s.abandoned - s.shortAbandoned) + s.unanswered;
+  return {
+    window: {from: iso(s.windowStartedAt), minutes: round(s.periodSeconds / 60)},
+    offered: s.offered,
+    answered: s.answered,
+    abandoned: s.abandoned,
+    shortAbandoned: s.shortAbandoned,
+    unanswered: s.unanswered,
+    transferred: s.transferred,
+    unknown: s.unknown,
+    outbound: s.outbound,
+    serviceLevel: pct(s.answeredWithinSl, base),
+    slaSeconds: s.serviceLevelSeconds,
+    answeredWithinSla: s.answeredWithinSl,
+    abandonRate: pct(s.abandoned - s.shortAbandoned, base),
+    asaSeconds: sec(ratio(s.answeredWaitSumMs, s.answered)),
+    avgTalkSeconds: sec(ratio(s.talkSumMs, s.talkCount)),
+    avgRingSeconds: sec(ratio(s.ringSumMs, s.ringCount)),
+    maxWaitSeconds: sec(s.maxWaitMs || null),
+    wrapUpMinutes: min(s.acwSumMs),
+    now: {
+      waiting: s.callsWaiting,
+      longestWaitSeconds: s.longestWaitStartedAt ? sec(now - s.longestWaitStartedAt) : 0,
+      talking: s.callsActive,
+      agents: {
+        total: s.agentsTotal,
+        available: s.agentsAvailable,
+        talking: s.agentsTalking,
+        paused: s.agentsPaused,
+        wrapUp: s.agentsWrapUp,
+        loggedOff: s.agentsLoggedOff,
+      },
+    },
+  };
+}
+
+const SUMMED = [
+  'offered',
+  'outbound',
+  'answered',
+  'unanswered',
+  'unknown',
+  'abandoned',
+  'shortAbandoned',
+  'transferred',
+  'answeredWaitSumMs',
+  'abandonedWaitSumMs',
+  'unansweredWaitSumMs',
+  'waitCount',
+  'talkSumMs',
+  'talkCount',
+  'acwSumMs',
+  'ringSumMs',
+  'ringCount',
+  'answeredWithinSl',
+  'callsWaiting',
+  'callsActive',
+  'agentsTotal',
+  'agentsAvailable',
+  'agentsTalking',
+  'agentsPaused',
+  'agentsWrapUp',
+  'agentsLoggedOff',
+];
+
+// The counters of several queues added up (counters first, rates after: never an average of rates). An agent in
+// two queues counts in both agent totals.
+export function sumStats(list) {
+  const items = list.filter(Boolean);
+  if (!items.length) return undefined;
+  const out = {};
+  for (const k of SUMMED) out[k] = items.reduce((n, s) => n + (s[k] ?? 0), 0);
+  out.maxWaitMs = Math.max(...items.map((s) => s.maxWaitMs ?? 0));
+  const waits = items.map((s) => s.longestWaitStartedAt).filter(Boolean);
+  if (waits.length) out.longestWaitStartedAt = Math.min(...waits);
+  out.windowStartedAt = Math.min(...items.map((s) => s.windowStartedAt ?? Infinity));
+  out.periodSeconds = Math.max(...items.map((s) => s.periodSeconds ?? 0));
+  const slas = [...new Set(items.map((s) => s.serviceLevelSeconds))];
+  out.serviceLevelSeconds = slas.length === 1 ? slas[0] : undefined;
+  return out;
+}
+
+// The figures of one agent in the window. Occupancy: the share of the time ready for calls that was spent on
+// calls, busyMs / (availableMs + busyMs).
+export function agentFigures(a) {
+  if (!a) return undefined;
+  return {
+    offered: a.offered,
+    answered: a.answered,
+    missed: a.missed,
+    answerRate: pct(a.answered, a.offered),
+    avgTalkSeconds: sec(ratio(a.talkSumMs, a.talkCount)),
+    avgRingToAnswerSeconds: sec(ratio(a.ringToAnswerSumMs, a.ringToAnswerCount)),
+    loggedInMinutes: min(a.loggedInMs),
+    availableMinutes: min(a.availableMs),
+    busyMinutes: min(a.busyMs),
+    pausedMinutes: min(a.pausedMs),
+    wrapUpMinutes: min(a.wrapUpMs),
+    occupancy: pct(a.busyMs, (a.availableMs ?? 0) + (a.busyMs ?? 0)),
+  };
+}
+
+// The per-agent counters of a queue are keyed by the agent id, <queue id>_<extension>: the same person has another
+// id in every queue. Added up per extension, for a person's figures across queues.
+export function agentStatsByExtension(services) {
+  const out = new Map();
+  for (const s of services) {
+    for (const [id, a] of Object.entries(s.stats?.agentStats ?? {})) {
+      const ext =
+        s.agents?.find((x) => x.id === id)?.userExtension ??
+        (id.startsWith(`${s.id}_`) ? id.slice(s.id.length + 1) : id);
+      const prev = out.get(ext);
+      if (!prev) out.set(ext, {...a});
+      else for (const [k, v] of Object.entries(a)) if (typeof v === 'number') prev[k] = (prev[k] ?? 0) + v;
+    }
+  }
+  return out;
+}
+
+// ── keeping a queue current from the events of the services topic ─────────────────────────────────────────────
+// A `service` event with eventTrigger service.init or service.update carries the whole queue; agent_join the
+// agents that joined, agent_leave the ids of those that left (nothing else), agent_update only what changed of the
+// agents named; service.end removes the queue. A `serviceCall` event (call_init, call_update, call_end) is one
+// call of a queue, with `action` (ring, cancel, answer, …) and the agents it concerns (relatedAgents).
+// `service_stats_update` replaces the stats.
+export function applyServiceEvent(queues, raw, now = Date.now()) {
+  const id = raw?.id;
+  if (!id) return;
+  const q = queues.get(id);
+  const ev = raw.event;
+  const trigger = raw.eventTrigger ?? '';
+  if (ev === 'service_stats_update' || trigger === 'service.stats_update') {
+    if (q && raw.stats) q.stats = raw.stats;
+    return;
+  }
+  if (ev === 'service') {
+    if (trigger === 'service.end') {
+      queues.delete(id);
+      return;
+    }
+    const next = q ?? {id, agents: [], calls: new Map()};
+    for (const k of ['pbx', 'name', 'strategy', 'maxCalls', 'aclGroup', 'timeZone'])
+      if (raw[k] !== undefined) next[k] = raw[k];
+    const agents = Array.isArray(raw.agents) ? raw.agents : [];
+    if (trigger === 'service.agent_leave') {
+      const gone = new Set(agents.map((a) => a.id));
+      next.agents = next.agents.filter((a) => !gone.has(a.id));
+    } else if (trigger === 'service.agent_update' && q) {
+      for (const a of agents) {
+        const i = next.agents.findIndex((x) => x.id === a.id);
+        if (i < 0) continue;
+        const prev = next.agents[i];
+        const merged = {...prev, ...Object.fromEntries(Object.entries(a).filter(([, v]) => v !== undefined))};
+        if (
+          merged.status !== prev.status ||
+          String(merged.paused) !== String(prev.paused) ||
+          merged.reason !== prev.reason
+        )
+          merged.since = raw.time ?? now;
+        next.agents[i] = merged;
+      }
+    } else if (trigger === 'service.agent_join' && q) {
+      for (const a of agents) {
+        const i = next.agents.findIndex((x) => x.id === a.id);
+        const added = {...a, since: raw.time ?? now};
+        if (i < 0) next.agents.push(added);
+        else next.agents[i] = added;
+      }
+    } else if (agents.length || !q) {
+      const prevById = new Map(next.agents.map((a) => [a.id, a]));
+      next.agents = agents.filter((a) => a.userExtension).map((a) => ({...a, since: prevById.get(a.id)?.since}));
+    }
+    // service.init and service.update list the calls waiting in the queue: a waiting call that is no longer listed
+    // has left it; answered calls are not listed and stay until their call_end.
+    if (Array.isArray(raw.calls) && (trigger === 'service.init' || trigger === 'service.update')) {
+      const listed = new Set(raw.calls.map(String));
+      for (const [cid, c] of next.calls)
+        if (!c.answeredBy && c.direction !== 'outgoing' && !listed.has(cid)) next.calls.delete(cid);
+      for (const cid of listed) if (!next.calls.has(cid)) next.calls.set(cid, {callId: cid, direction: 'incoming'});
+    }
+    if (raw.stats) next.stats = raw.stats;
+    queues.set(id, next);
+    return;
+  }
+  if ((ev === 'serviceCall' || ev === 'service_call' || (!ev && raw.callId)) && q && raw.callId) {
+    if (trigger === 'service.call_end') {
+      q.calls.delete(raw.callId);
+      return;
+    }
+    const c = q.calls.get(raw.callId) ?? {callId: raw.callId, ringing: []};
+    c.direction = raw.direction ?? c.direction ?? 'incoming';
+    c.start = raw.startTime ?? c.start ?? raw.time ?? now;
+    if (raw.customer) c.customer = raw.customer;
+    c.ringing ??= [];
+    const related = raw.relatedAgents ?? [];
+    if (raw.action === 'ring') c.ringing = [...new Set([...c.ringing, ...related])];
+    else if (raw.action === 'cancel') c.ringing = c.ringing.filter((x) => !related.includes(x));
+    else if (raw.action === 'answer') {
+      c.ringing = [];
+      c.answeredBy = related[0];
+      c.answeredAt = raw.answerTime ?? raw.time ?? now;
+    }
+    q.calls.set(raw.callId, c);
+  }
+}

package/src/live/text.mjs

@@ -0,0 +1,318 @@
+// Text output of `wx live`: queues, agents, conversations and presence as aligned tables, the events of `watch` and
+// `transcript --follow` as one readable line each. The JSON output is the data itself (src/live/views.mjs).
+import {duration, localTime, oneLine, paint, table} from 'wldx-core/format';
+
+// Agents are listed under their queue when this many queues or fewer are shown (else the table of queues only).
+export const AGENT_LIST_MAX = 10;
+
+const clockTime = (value) => localTime(value, {seconds: true}).slice(11);
+const num = (v) => (v === null || v === undefined ? '' : String(v));
+const percent = (v) => (v === null || v === undefined ? '-' : `${v}%`);
+const secs = (v) => (v === null || v === undefined ? '-' : duration(v));
+const isPaused = (a) => a?.paused === true || a?.paused === 'true';
+
+// A person in a call: name, else phone, else extension; the extension in brackets when there is a name.
+function who(p) {
+  if (!p) return '';
+  const ext = p.extension ?? p.userExtension;
+  const name = p.name || p.phone || ext || '';
+  return ext && name !== ext ? `${name} (${ext})` : String(name);
+}
+
+function agentStatus(a, c) {
+  const status = isPaused(a) ? 'paused' : String(a.status ?? '');
+  if (status === 'available') return c.green(status);
+  if (status === 'paused') return c.yellow(status);
+  return c.dim(status);
+}
+
+function windowLabel(w) {
+  if (!w) return '';
+  return w.from ? `since ${localTime(w.from)}${w.minutes ? ` (${w.minutes} min)` : ''}` : '';
+}
+
+// One line of figures: of a queue, or of all the queues shown.
+export function figuresLine(s) {
+  if (!s) return '';
+  const parts = [
+    `offered ${num(s.offered)}`,
+    `answered ${num(s.answered)}`,
+    `abandoned ${num(s.abandoned)}${s.shortAbandoned ? ` (${s.shortAbandoned} short)` : ''}`,
+    `SL ${percent(s.serviceLevel)}${s.slaSeconds ? ` (${s.slaSeconds} s)` : ''}`,
+    `ASA ${secs(s.asaSeconds)}`,
+    `talk ${secs(s.avgTalkSeconds)}`,
+  ];
+  if (s.now)
+    parts.push(
+      `waiting ${num(s.now.waiting)}${s.now.longestWaitSeconds ? ` (longest ${duration(s.now.longestWaitSeconds)})` : ''}`,
+      `talking ${num(s.now.talking)}`,
+    );
+  return parts.join(' · ');
+}
+
+function agentsTable(agents, c, withStats) {
+  const head = [
+    'AGENT',
+    'EXT',
+    'STATUS',
+    'REASON',
+    'MESSAGE',
+    ...(withStats ? ['ANSWERED', 'MISSED', 'OCCUPANCY'] : []),
+  ];
+  const rows = agents.map((a) => [
+    a.name ?? '',
+    a.extension ?? a.userExtension ?? '',
+    agentStatus(a, c),
+    a.reason ? (a.reason === 'DND' ? c.red(a.reason) : c.yellow(a.reason)) : '',
+    oneLine(a.message ?? '', 40),
+    ...(withStats ? [num(a.stats?.answered), num(a.stats?.missed), percent(a.stats?.occupancy)] : []),
+  ]);
+  return table([head.map((h) => c.dim(h)), ...rows]).map((l) => `  ${l}`);
+}
+
+export function queuesText(r, ctx) {
+  const c = paint(ctx);
+  const withStats = Boolean(r.stats);
+  const lines = [];
+  const pbxCount = r.pbxs ? Object.keys(r.pbxs).length : 0;
+  lines.push(
+    `${r.total} queue${r.total === 1 ? '' : 's'}${pbxCount ? ` on ${pbxCount} PBXs` : ''}, ${r.callsWaitingOrTalking} call${r.callsWaitingOrTalking === 1 ? '' : 's'} waiting or talking`,
+  );
+  if (withStats) lines.push(`All shown ${windowLabel(r.stats.window)}: ${figuresLine(r.stats)}`);
+  if (!r.queues?.length) return lines;
+  lines.push('');
+  const head = [
+    'QUEUE',
+    'CALLS',
+    'AVAILABLE',
+    'PAUSED',
+    'STRATEGY',
+    ...(pbxCount ? ['PBX'] : []),
+    ...(withStats ? ['OFFERED', 'ANSWERED', 'ABANDONED', 'SL', 'ASA', 'WAITING'] : []),
+  ];
+  const rows = r.queues.map((q) => {
+    const agents = q.agents ?? [];
+    const available = agents.filter((a) => a.status === 'available' && !isPaused(a)).length;
+    const paused = agents.filter(isPaused).length;
+    const s = q.figures ?? q.stats; // with --full: the raw stats and the figures beside them
+    return [
+      oneLine(q.name ?? q.id, 40),
+      q.calls ? c.bold(String(Array.isArray(q.calls) ? q.calls.length : q.calls)) : '0',
+      `${available}/${agents.length}`,
+      paused ? c.yellow(String(paused)) : '0',
+      q.strategy ?? '',
+      ...(pbxCount ? [q.pbx ?? ''] : []),
+      ...(withStats
+        ? [
+            num(s?.offered),
+            num(s?.answered),
+            num(s?.abandoned),
+            percent(s?.serviceLevel),
+            secs(s?.asaSeconds),
+            num(s?.now?.waiting),
+          ]
+        : []),
+    ];
+  });
+  lines.push(...table([head.map((h) => c.dim(h)), ...rows]));
+  if (r.queues.length > AGENT_LIST_MAX) {
+    ctx?.info?.(
+      `The agents are listed for ${AGENT_LIST_MAX} queues or fewer: narrow with --name, --busy, --paused or --active, or use --output json.`,
+    );
+    return lines;
+  }
+  for (const q of r.queues) {
+    lines.push(
+      '',
+      c.bold(`${q.name ?? q.id}`) +
+        c.dim(` · ${q.strategy ?? ''}${q.maxCalls ? ` · max ${q.maxCalls} calls` : ''} · ${q.id}`),
+    );
+    if (Array.isArray(q.callIds) && q.callIds.length) lines.push(`  calls: ${q.callIds.join(', ')}`);
+    if (q.figures ?? q.stats) lines.push(`  ${figuresLine(q.figures ?? q.stats)}`);
+    if (q.agents?.length) lines.push(...agentsTable(q.agents, c, withStats));
+    else lines.push(c.dim('  no agents'));
+  }
+  return lines;
+}
+
+const lastFlow = (item) => (Array.isArray(item.flows) ? item.flows.at(-1) : undefined);
+
+// One conversation: [type, status, who, detail].
+function conversationCells(item) {
+  if (item.type === 'call' || item.event === 'call') {
+    const f = lastFlow(item) ?? {};
+    const legs = Array.isArray(item.flows) && item.flows.length > 1 ? ` · ${item.flows.length} legs` : '';
+    return [
+      'call',
+      f.status ?? '',
+      `${who(f.caller)} → ${who(f.callee)}`,
+      [f.direction, f.queue && `queue ${f.queue}`, f.transcription && `transcription ${f.transcription}`]
+        .filter(Boolean)
+        .join(' · ') + legs,
+    ];
+  }
+  const sentiment = item.insights?.sentiment !== undefined ? `sentiment ${item.insights.sentiment}` : '';
+  if (item.type === 'chat' || item.event === 'chat') {
+    const people = (item.customers ?? [])
+      .map((p) => p.name)
+      .filter(Boolean)
+      .join(', ');
+    return [
+      'chat',
+      item.status ?? '',
+      people,
+      [item.subject && oneLine(item.subject, 60), sentiment].filter(Boolean).join(' · '),
+    ];
+  }
+  if (item.type === 'conference' || item.event === 'conference') {
+    return [
+      'conference',
+      '',
+      `${item.participants?.length ?? 0} participants`,
+      [item.subject && oneLine(item.subject, 60), sentiment].filter(Boolean).join(' · '),
+    ];
+  }
+  return [String(item.type ?? item.event ?? ''), '', '', item.key ?? ''];
+}
+
+export function conversationsText(r, ctx) {
+  const c = paint(ctx);
+  const counts = Object.entries(r.byType ?? {})
+    .map(([k, n]) => `${k}s ${n}`)
+    .join(', ');
+  const lines = [
+    `${r.total} in progress${counts ? ` (all: ${counts})` : ''}${r.shown < r.total ? `, newest ${r.shown} shown` : ''}`,
+  ];
+  if (!r.items?.length) return lines;
+  lines.push('');
+  const rows = r.items.map((item) => [
+    localTime(item.start),
+    ...conversationCells(item).map((v, i) => (i === 1 && v ? c.cyan(v) : oneLine(v, 80))),
+    c.dim(item.id ?? ''),
+  ]);
+  lines.push(...table([['STARTED', 'TYPE', 'STATUS', 'WHO', 'DETAIL', 'ID'].map((h) => c.dim(h)), ...rows]));
+  return lines;
+}
+
+function presenceStatus(status, c) {
+  const s = String(status ?? '');
+  if (s === 'ONLINE' || s === 'AVAILABLE') return c.green(s);
+  if (s === 'DND') return c.red(s);
+  if (s === 'AWAY') return c.yellow(s);
+  return c.dim(s);
+}
+
+export function presenceText(r, ctx) {
+  const c = paint(ctx);
+  const rows = (r.presence ?? []).map((p) => [
+    p.extension ?? '',
+    presenceStatus(p.status, c),
+    oneLine(p.message ?? '', 50),
+    p.until ? localTime(p.until) : '',
+    p.phone ?? p.telephony ?? '',
+    p.company ? `company ${p.company}` : '',
+  ]);
+  return table([['EXT', 'STATUS', 'MESSAGE', 'UNTIL', 'PHONE', ''].map((h) => c.dim(h)), ...rows]);
+}
+
+const textLine = (t) =>
+  `${t.at !== undefined ? `[${clockTime(t.at)}] ` : ''}${t.name ?? t.speaker ?? '?'}: ${t.text ?? ''}`;
+
+export function transcriptText(r, ctx) {
+  const c = paint(ctx);
+  const head = [`${r.type} ${r.id}`];
+  if (r.call) {
+    const [, status, people] = conversationCells(r.call);
+    head.push([status, people].filter(Boolean).join(' · '));
+  }
+  const lines = [c.bold(head.filter(Boolean).join(': '))];
+  if (!r.transcript?.length) lines.push(c.dim('nothing transcribed yet'));
+  for (const t of r.transcript ?? []) lines.push(textLine(t));
+  for (const a of r.annotations ?? []) lines.push(c.dim(`${a.key}: ${oneLine(JSON.stringify(a.payload), 100)}`));
+  return lines;
+}
+
+// One event of `watch` or `transcript --follow` as one line: the local time, the event, what it says.
+export function eventText(e, ctx) {
+  const c = paint(ctx);
+  const d = e.data ?? {};
+  let what;
+  switch (e.event) {
+    case 'READY':
+    case 'RECONNECTED':
+      what = `watching ${(d.topics ?? []).join(', ') || 'nothing'}${d.calls ? ' (calls only)' : ''}${d.mine ? ' (my calls)' : ''}${d.extension ? ` · extension ${d.extension}` : ''}${d.license ? ` · ${d.license}` : ''}`;
+      break;
+    case 'RECONNECTING':
+      what =
+        d.reason === 'token'
+          ? 'renewing the login'
+          : `connection lost (code ${d.code}), attempt ${d.attempt} in ${d.inSeconds} s`;
+      break;
+    case 'ERROR':
+      what = c.red(`${d.message}${d.code ? ` (${d.code})` : ''}`);
+      break;
+    case 'QUEUES':
+      what = `${d.queues} queues known${d.stats ? ` · stats ${d.stats.periodMinutes ? `last ${d.stats.periodMinutes} min` : 'today'}, SLA ${d.stats.serviceLevelSeconds} s` : ''}`;
+      break;
+    case 'QUEUE': {
+      const agents = (d.agents ?? []).map((a) =>
+        `${a.name ?? a.extension ?? a.userExtension ?? '?'} ${isPaused(a) ? 'paused' : (a.status ?? '')}${a.reason ? ` ${a.reason}` : ''}${a.message ? ` "${oneLine(a.message, 30)}"` : ''}`.trim(),
+      );
+      what = [d.trigger ?? d.eventTrigger, d.name ?? d.id, d.calls ? `${d.calls} calls` : '', agents.join('; ')]
+        .filter(Boolean)
+        .join(' · ');
+      break;
+    }
+    case 'QUEUE_CALL':
+      what = [
+        d.trigger ?? d.eventTrigger,
+        `queue ${d.queueId ?? d.id}`,
+        `call ${d.callId}`,
+        d.direction,
+        d.customer && (typeof d.customer === 'object' ? (d.customer.phone ?? d.customer.name) : d.customer),
+        d.agents !== undefined && `${d.agents} agents`,
+      ]
+        .filter(Boolean)
+        .join(' · ');
+      break;
+    case 'QUEUE_STATS':
+      what = `${d.name ?? d.id}: ${figuresLine(d)}`;
+      break;
+    case 'PRESENCE':
+      what = [
+        d.extension,
+        d.status,
+        d.message && `"${oneLine(d.message, 40)}"`,
+        d.until && `until ${localTime(d.until)}`,
+        d.phone ?? d.telephony,
+      ]
+        .filter(Boolean)
+        .join(' · ');
+      break;
+    case 'SNAPSHOT':
+      what = `${d.type} ${d.id}: ${d.transcript?.length ?? 0} lines so far${(d.transcript ?? []).map((t) => `\n  ${textLine(t)}`).join('')}`;
+      break;
+    case 'TEXT':
+      what = `${d.final === false ? c.dim('(partial) ') : ''}${textLine(d)}`;
+      break;
+    case 'ANNOTATION':
+      what = `${d.key}: ${oneLine(JSON.stringify(d.payload), 100)}`;
+      break;
+    case 'END':
+      what = `${d.id} ended (${d.event})`;
+      break;
+    default: {
+      if (/^(CALL|CHAT|CONFERENCE)(_|$)/.test(e.event)) {
+        const [, status, people, detail] = conversationCells(d);
+        const extra = d.key ? `${d.key}${d.insights ? ` ${oneLine(JSON.stringify(d.insights), 80)}` : ''}` : '';
+        what = [d.trigger, status, people, detail, extra, c.dim(d.id ?? '')]
+          .filter(Boolean)
+          .map((v) => oneLine(v, 100))
+          .join(' · ');
+      } else {
+        what = oneLine(JSON.stringify(d), 140);
+      }
+    }
+  }
+  return `${c.dim(clockTime(ctx?.clock ? ctx.clock() : Date.now()))} ${c.bold(e.event)} ${what}`;
+}