@opengeni/react 6.8.0 → 6.9.1-canary.41937124785001

package/src/meetings/meetings-pages.test.tsx

@@ -1503,6 +1503,44 @@ describe("Meeting page", () => {
     }
   });
 
+  test("a delayed subscription plan refusal offers upgrading, not adding credits", async () => {
+    const fixture = createMeetingsFixture();
+    const client = {
+      ...fixture.client,
+      getRecording: async (workspaceId: string, id: string) => {
+        const recording = await fixture.client.getRecording(workspaceId, id);
+        return {
+          ...recording,
+          transcript: { ...recording.transcript!, errorCode: "subscription_plan_required" },
+        };
+      },
+    } as typeof fixture.client;
+    let opened = 0;
+    const view = await render(
+      <MeetingDetailPage
+        workspaceId={fixture.workspaceId}
+        recordingId={FAILED_RECORDING_ID}
+        viewerSubjectId={fixture.viewerSubjectId}
+        recordings={client}
+        onBack={() => {}}
+        onOpenBilling={() => {
+          opened++;
+        }}
+      />,
+    );
+    try {
+      await waitForText(view.container, "Upgrade to Pro to use your own subscription.");
+      const buttons = [...view.container.querySelectorAll("button")];
+      expect(buttons.some((button) => button.textContent?.trim() === "Add credits")).toBe(false);
+      const upgrade = buttons.find((button) => button.textContent?.trim() === "Upgrade to Pro")!;
+      expect(upgrade).toBeDefined();
+      await act(async () => upgrade.click());
+      expect(opened).toBe(1);
+    } finally {
+      await view.unmount();
+    }
+  });
+
   /** The fixture's failed meeting, refused for credits on the deployment's model. */
   async function creditRefusal(withSubscription: boolean) {
     const fixture = createMeetingsFixture();

package/src/meetings/recorder-context.tsx

@@ -42,9 +42,14 @@ export type MeetingRecorder = UseRecorderResult;
  * A recording someone asked for outside the recorder, such as from a desktop
  * call notification. An empty title leaves the name to Opengeni; `app` marks
  * a title the app guessed (the call app's name), which a calendar event or
- * the conversation replaces.
+ * the conversation replaces. `calendarEvent` is the owner's calendar event
+ * the meeting is of, such as one joined from a reminder; it names the meeting.
  */
-export type MeetingStartRequest = { title: string; titleSource?: "person" | "app" };
+export type MeetingStartRequest = {
+  title: string;
+  titleSource?: "person" | "app";
+  calendarEvent?: { provider: "google" | "microsoft"; id: string };
+};
 
 export type MeetingRecorderStore = {
   get: () => MeetingRecorder | null;
@@ -280,10 +285,28 @@ function useDesktopMeetingRequests(
         // Nobody signed in: a start kept for later would record, for whoever
         // signs in next, a call that may be long over.
         if (latest.current.signedOut) return;
-        // Already recording shows that recording rather than start a second one.
-        // The call app's name is only a guess at the meeting's.
+        // The call app's name is only a guess at the meeting's; the calendar
+        // event a reminder joined names it.
+        const start: MeetingStartRequest = {
+          title: request.title,
+          titleSource: "app",
+          ...(request.calendarEvent ? { calendarEvent: request.calendarEvent } : {}),
+        };
+        // Already recording shows that recording rather than start a second
+        // one, unless the person chose to switch to recording the next meeting:
+        // this one stops and is kept, then the next starts.
         if (canStartRecording(recorder?.state)) {
-          store.requestStart({ title: request.title, titleSource: "app" });
+          store.requestStart(start);
+        } else if (
+          request.replace === true &&
+          recorder &&
+          (recorder.state === "recording" || recorder.state === "paused")
+        ) {
+          // A stop that fails leaves that recording showing its error, and starts nothing.
+          void recorder.stop().then(
+            () => store.requestStart(start),
+            () => undefined,
+          );
         }
         latest.current.onOpenMeetings?.();
         return;

package/src/meetings/recorder-panel.tsx

@@ -48,7 +48,7 @@ import { Notice } from "../ui/notice";
 import { cn } from "../app/lib/utils";
 
 import { formatClock, ownerLiveLaneName } from "../recordings";
-import type { MeetingRecorder } from "./recorder-context";
+import type { MeetingRecorder, MeetingStartRequest } from "./recorder-context";
 import { canStartRecording } from "./recorder-state";
 import { LiveTranscript, liveStatus, type LiveTranscriptLine } from "./live-transcript";
 import { DETECT_LANGUAGE, meetingLanguageOptions } from "./meeting-languages";
@@ -618,7 +618,7 @@ function RecorderPanelContent({
    */
   autoStart?: {
     pending: boolean;
-    take: () => { title: string; titleSource?: "person" | "app" } | null;
+    take: () => MeetingStartRequest | null;
   } | null;
   /** The host's own id for what new recordings belong to, such as a project. */
   externalRef?: string | null | undefined;
@@ -645,8 +645,15 @@ function RecorderPanelContent({
   const state = recorder?.state ?? "idle";
   const live = state === "recording" || state === "paused" || state === "stopping";
 
-  /** `guess` is the app's name for the meeting, used only when nobody typed one. */
-  const start = async (titleText: string = title, guess?: string) => {
+  /**
+   * `guess` is the app's name for the meeting, used only when nobody typed
+   * one; `calendarEvent` the calendar event it is of, which names it.
+   */
+  const start = async (
+    titleText: string = title,
+    guess?: string,
+    calendarEvent?: MeetingStartRequest["calendarEvent"],
+  ) => {
     if (!recorder) return;
     setErrorDismissed(false);
     const name = titleText.trim();
@@ -658,6 +665,7 @@ function RecorderPanelContent({
       systemAudio: tabAudio,
       ...(liveOn ? { liveTranscript: true } : {}),
       ...(externalRef ? { externalRef } : {}),
+      ...(calendarEvent ? { calendarEvent } : {}),
       // Names their microphone in the transcript when Opengeni has no name for them.
       ...(viewerName?.trim() ? { ownerName: viewerName } : {}),
       // Sent even when it's the workspace's, so this meeting keeps it.
@@ -679,7 +687,7 @@ function RecorderPanelContent({
     if (!request) return;
     // The call app's name is a guess: a title already typed wins over it.
     if (request.titleSource === "app") {
-      void startRef.current(undefined, request.title);
+      void startRef.current(undefined, request.title, request.calendarEvent);
       return;
     }
     // A start without a title (the Start recording key) keeps one already typed, as the button does.

package/src/meetings/recorder-workspace.test.tsx

@@ -6,7 +6,11 @@ import { GlobalRegistrator } from "@happy-dom/global-registrator";
 import { act, useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
 import { createRoot } from "react-dom/client";
 
-import type { MeetingRecorder, MeetingRecorderStore } from "./recorder-context";
+import type {
+  MeetingRecorder,
+  MeetingRecorderStore,
+  MeetingStartRequest,
+} from "./recorder-context";
 
 beforeAll(() => {
   GlobalRegistrator.register();
@@ -83,7 +87,17 @@ async function until(check: () => boolean) {
 
 type Desktop = {
   listener:
-    | ((request: { kind: "record"; title?: string } | { kind: "stop" } | { kind: "open" }) => void)
+    | ((
+        request:
+          | {
+              kind: "record";
+              title?: string;
+              calendarEvent?: { provider: "google" | "microsoft"; id: string };
+              replace?: boolean;
+            }
+          | { kind: "stop" }
+          | { kind: "open" },
+      ) => void)
     | null;
 };
 
@@ -118,7 +132,7 @@ function mountProvider() {
   };
   const opened: string[] = [];
   const meetingsOpened: string[] = [];
-  let pendingStart: () => boolean = () => false;
+  let pendingStart: () => MeetingStartRequest | null = () => null;
   let open: ((recordingId: string, workspaceId: string) => boolean) | null = null;
   function Probe() {
     const current = useMeetingRecorder();
@@ -129,23 +143,24 @@ function mountProvider() {
   }
   function PendingStart() {
     const { take } = usePendingMeetingStart();
-    pendingStart = () => take() !== null;
+    pendingStart = take;
     return null;
   }
   const container = document.createElement("div");
   document.body.append(container);
   const root = createRoot(container);
-  return {
+  const view = {
     seen,
     opened,
     meetingsOpened,
     // Taking the pending start clears provider state, so it runs inside act.
-    takePendingStart: () => {
-      let taken = false;
+    takePendingStart: () => view.takePendingRequest() !== null,
+    takePendingRequest: () => {
+      let taken: MeetingStartRequest | null = null;
       act(() => {
         taken = pendingStart();
       });
-      return taken;
+      return taken as MeetingStartRequest | null;
     },
     open: (recordingId: string, workspaceId: string) => open!(recordingId, workspaceId),
     render: (workspaceId: string | null, options: { scope?: string | null } = {}) =>
@@ -170,6 +185,7 @@ function mountProvider() {
       container.remove();
     },
   };
+  return view;
 }
 
 describe("A recording and the workspace it was made in", () => {
@@ -423,4 +439,37 @@ describe("A recording and the person who made it", () => {
       removeDesktop();
     }
   });
+  test("a reminder's Join and record this one stops the recording, then starts the next meeting's", async () => {
+    events.length = 0;
+    const desktop = installDesktop();
+    const view = mountProvider();
+    try {
+      await view.render("workspace-a");
+      await until(() => view.seen.recorder !== null);
+      await settle();
+      await act(async () => setStates.get("workspace-a")!("recording"));
+      const calendarEvent = { provider: "google" as const, id: "event-2" };
+      // Without replace, a reminder's Join shows the recording going on.
+      await act(async () =>
+        desktop.listener!({ kind: "record", title: "Planning", calendarEvent }),
+      );
+      expect(view.takePendingRequest()).toBeNull();
+      expect(view.seen.recorder?.state).toBe("recording");
+      // With it, the recording stops and is kept, then the next one starts for its event.
+      await act(async () =>
+        desktop.listener!({ kind: "record", title: "Planning", calendarEvent, replace: true }),
+      );
+      await settle();
+      expect(view.seen.recorder?.state).toBe("stopped");
+      expect(view.takePendingRequest()).toEqual({
+        title: "Planning",
+        titleSource: "app",
+        calendarEvent,
+      });
+      expect(view.meetingsOpened).toEqual(["workspace-a", "workspace-a"]);
+    } finally {
+      await view.unmount();
+      removeDesktop();
+    }
+  });
 });

package/src/messages/en.ts

@@ -2524,6 +2524,7 @@ export const englishMessages = {
   "meetings.detailPage.aboutLessThan001": "Less than $0.01 for this {duration} meeting.",
   "meetings.detailPage.aboutThisTranscript": "About this transcript",
   "meetings.detailPage.addCredits": "Add credits",
+  "meetings.detailPage.upgradeToPro": "Upgrade to Pro",
   "meetings.detailPage.auto": "Auto",
   "meetings.detailPage.backToMeetings": "Back to Meetings",
   "meetings.detailPage.canTLoadThePreview": "Can't show the live text right now",
@@ -2945,6 +2946,8 @@ export const englishMessages = {
     "The credit allowance is used up for now. An admin can raise it, or transcribe with a model that doesn't use credits.",
   "meetings.recordings.errorMonthlyCostLimit":
     "This organization has reached its monthly spending limit. An admin can raise it, or transcribe with a model that doesn't use credits.",
+  "meetings.recordings.errorSubscriptionApiUnavailable":
+    "Connected subscriptions aren't available through the API. Choose a credit-billed model.",
   "meetings.recordings.errorPolicyBlocked":
     "This organization's policy doesn't allow this model. Try another model.",
   "meetings.recordings.errorTimedOut":
@@ -3740,6 +3743,7 @@ export const englishMessages = {
   "native.timeline.messages.onAMachine": "On a machine",
   "native.timeline.messages.output": "Output",
   "native.timeline.messages.pauseGoal": "Pause goal",
+  "native.timeline.messages.paused": "Paused",
   "native.timeline.messages.pin": "Pin",
   "native.timeline.messages.pinned": "Pinned",
   "native.timeline.messages.proposedKnowledge": "Proposed knowledge",
@@ -6081,6 +6085,7 @@ export const englishMessages = {
   "timeline.turnSummary.contextCompactedExpandForDetails": "Context compacted; expand for details",
   "timeline.turnSummary.copyTurn": "Copy turn",
   "timeline.turnSummary.interrupted": "· interrupted",
+  "timeline.turnSummary.paused": "Paused",
   "timeline.turnSummary.preparation": "Preparation",
   "timeline.turnSummary.steps": "Steps",
   "timeline.turnSummary.waiting": "Waiting",

package/src/recordings-model.ts

@@ -175,6 +175,7 @@ const PROVIDER_FAILURES = new Set([
   "provider_unauthorized",
   "provider_quota_exceeded",
   "policy_blocked",
+  "subscription_api_unavailable",
 ]);
 /** Failures of the model: another model, even the same provider's, may work. */
 const MODEL_FAILURES = new Set([
@@ -211,6 +212,8 @@ export function transcriptFixModel(
           : 2;
   const candidates = models.filter((entry) => {
     if (!entry.available || !entry.capabilities.batch) return false;
+    if (code === "subscription_api_unavailable" && entry.funding === "workspace_subscription")
+      return false;
     if (failed && entry.providerId === failed.providerId) {
       if (!MODEL_FAILURES.has(code) || entry.model === failed.model) return false;
     }
@@ -259,6 +262,10 @@ export function transcriptErrorText(
   } | null,
 ): string {
   switch (code) {
+    case "subscription_plan_required":
+      return msg("lib.format.subscriptionUpgradeRequiredHeadline");
+    case "subscription_api_unavailable":
+      return msg("meetings.recordings.errorSubscriptionApiUnavailable");
     case "missing_provider_key": {
       if (!model) return msg("meetings.recordings.errorMissingProviderKey");
       const names = { modelName: model.modelName, providerName: model.providerName };

package/src/session.ts

@@ -141,9 +141,16 @@ export {
   extractSessionRef,
   groupTimeline,
   sessionStatusFromEvents,
+  timelineLivePause,
+  timelinePauseSpans,
   toolDisplayName,
 } from "./timeline/projection";
-export type { GroupTimelineOptions } from "./timeline/projection";
+export type {
+  GroupTimelineOptions,
+  TimelineLivePause,
+  TimelinePauseSpan,
+} from "./timeline/projection";
+export { useTimelinePauses } from "./timeline/use-timeline-pauses";
 export type {
   ActivityItem,
   AgentMessageItem,

package/src/timeline/index.ts

@@ -24,10 +24,13 @@ export {
   groupTimeline,
   sessionStatusFromEvents,
   mcpToolLeaf,
+  timelineLivePause,
+  timelinePauseSpans,
   toolDisplayName,
   toolMatchesLeaf,
 } from "./projection";
-export type { GroupTimelineOptions } from "./projection";
+export type { GroupTimelineOptions, TimelineLivePause, TimelinePauseSpan } from "./projection";
+export { useTimelinePauses } from "./use-timeline-pauses";
 
 // item types
 export type {

package/src/timeline/projection.ts

@@ -2482,6 +2482,184 @@ export function sessionStatusFromEvents(events: SessionEvent[]): SessionStatus |
   return null;
 }
 
+/**
+ * A span in which the session's work was paused: by Pause of the chat, of
+ * an ancestor, or of the workspace. An open span (no `endedAt`) is a pause
+ * still in force.
+ */
+export type TimelinePauseSpan = { startedAt: string; endedAt?: string };
+
+/**
+ * The host's live view of the session's Pause, from its effective control.
+ * `since` is when the pause in force began, when known. `resumedAt` is when
+ * the host saw the pause end, for a resume whose events have not arrived.
+ */
+export type TimelineLivePause = {
+  paused: boolean;
+  since?: string | null | undefined;
+  resumedAt?: string | null | undefined;
+};
+
+/** Interruption reasons that park a turn for Resume rather than end it. */
+const PAUSE_INTERRUPTION_REASONS: ReadonlySet<unknown> = new Set([
+  "session_pause",
+  "workspace_pause",
+]);
+
+type LivePauseBlocker = { changedAt?: string | null | undefined };
+
+/**
+ * The live pause from an effective session control; undefined when it is
+ * unknown. A pause in force since several blockers took hold began with the
+ * earliest of them.
+ */
+export function timelineLivePause(
+  control:
+    | {
+        state: string;
+        primaryBlocker?: LivePauseBlocker | null | undefined;
+        blockers?: readonly LivePauseBlocker[] | null | undefined;
+      }
+    | null
+    | undefined,
+): TimelineLivePause | undefined {
+  if (!control) return undefined;
+  if (control.state !== "paused") return { paused: false };
+  let since: string | null = null;
+  for (const blocker of [control.primaryBlocker, ...(control.blockers ?? [])]) {
+    const changedAt = blocker?.changedAt;
+    if (changedAt && (since === null || Date.parse(changedAt) < Date.parse(since)))
+      since = changedAt;
+  }
+  return { paused: true, since };
+}
+
+/** Events that start or end a pause span. */
+const PAUSE_EVENT_TYPES: ReadonlySet<string> = new Set([
+  "session.control.paused",
+  "session.control.resumed",
+  "turn.recovery.requested",
+  "session.status.changed",
+  "turn.started",
+]);
+
+/**
+ * When the session's work was paused, from its events and (when the host
+ * knows it) its live control.
+ *
+ * Pause parks the running turn for Resume instead of ending it, so the turn
+ * stays open. A direct Pause records `session.control.paused`; a Pause of an
+ * ancestor or of the workspace reaches the chat only as the interruption
+ * (`turn.recovery.requested` with a pause reason) and the parked idle status.
+ * Work resumes with `session.control.resumed`, or when the turn runs again.
+ * A wait that a pause held without interrupting anything has no events at
+ * all, so the live control decides whether a pause is in force now, and
+ * `observed` carries pauses the host saw begin and end only through it.
+ */
+export function timelinePauseSpans(
+  events: readonly SessionEvent[],
+  live?: TimelineLivePause | null,
+  observed: readonly TimelinePauseSpan[] = [],
+): TimelinePauseSpan[] {
+  let latest: SessionEvent | undefined;
+  const relevant: SessionEvent[] = [];
+  for (const event of events) {
+    if (!latest || event.sequence > latest.sequence) latest = event;
+    if (PAUSE_EVENT_TYPES.has(event.type)) relevant.push(event);
+  }
+  relevant.sort((left, right) => left.sequence - right.sequence);
+  const spans: TimelinePauseSpan[] = [];
+  let open: TimelinePauseSpan | null = null;
+  // Cancel also leaves the control paused while the turn winds down; that is
+  // not a pause of the work, which is ending.
+  let cancelling = false;
+  for (const event of relevant) {
+    const payload = asRecord(event.payload);
+    if (
+      (event.type === "session.control.paused" && payload.terminal === true) ||
+      // A parent's Cancel reaches its sub-chats as their status alone.
+      (event.type === "session.status.changed" && payload.status === "cancelled")
+    ) {
+      cancelling = true;
+      continue;
+    }
+    const starts =
+      event.type === "session.control.paused" ||
+      (event.type === "turn.recovery.requested" &&
+        PAUSE_INTERRUPTION_REASONS.has(payload.reason)) ||
+      (event.type === "session.status.changed" &&
+        payload.status === "idle" &&
+        payload.reason === "paused_recovery_settled");
+    if (starts) {
+      open ??= { startedAt: event.occurredAt };
+      continue;
+    }
+    if (
+      event.type === "session.control.resumed" ||
+      event.type === "turn.started" ||
+      (event.type === "session.status.changed" && payload.status === "running")
+    ) {
+      cancelling = false;
+      if (open) {
+        spans.push({ startedAt: open.startedAt, endedAt: event.occurredAt });
+        open = null;
+      }
+    }
+  }
+  const latestAt = latest?.occurredAt;
+  if (live?.paused && !cancelling) {
+    const startedAt = open?.startedAt ?? live.since ?? latestAt;
+    if (startedAt) spans.push({ startedAt });
+  } else if (open) {
+    if (live) {
+      // The host already sees the session running again; its resume events
+      // are still on their way. End the pause when the host saw it end.
+      const endedAt = live.resumedAt ?? latestAt ?? open.startedAt;
+      spans.push({
+        startedAt: open.startedAt,
+        endedAt: Date.parse(endedAt) > Date.parse(open.startedAt) ? endedAt : open.startedAt,
+      });
+    } else {
+      spans.push(open);
+    }
+  }
+  // A pause seen only through the live control, by the host's clock; skip it
+  // where the events record the same pause.
+  const recorded = [...spans];
+  for (const span of observed) {
+    if (!span.endedAt) continue;
+    const start = Date.parse(span.startedAt);
+    const end = Date.parse(span.endedAt);
+    const overlaps = recorded.some(
+      (other) =>
+        Date.parse(other.startedAt) < end &&
+        (other.endedAt === undefined || Date.parse(other.endedAt) > start),
+    );
+    if (!overlaps) spans.push(span);
+  }
+  return spans;
+}
+
+/** Total length of the union of intervals, each clipped to `[from, to)`. */
+function unionLength(
+  intervals: ReadonlyArray<readonly [number, number]>,
+  from: number,
+  to: number,
+): number {
+  const clipped = intervals
+    .map(([start, end]) => [Math.max(start, from), Math.min(end, to)] as const)
+    .filter(([start, end]) => Number.isFinite(start) && Number.isFinite(end) && end > start)
+    .sort((left, right) => left[0] - right[0]);
+  let total = 0;
+  let cursor = Number.NEGATIVE_INFINITY;
+  for (const [start, end] of clipped) {
+    const begin = Math.max(start, cursor);
+    if (end > begin) total += end - begin;
+    cursor = Math.max(cursor, end);
+  }
+  return total;
+}
+
 /* ----------------------------------------------------------------------------
    Visual grouping: consecutive activity items (reasoning / tools / workers /
    sandbox) cluster into collapsible blocks. Once a turn settles, the full
@@ -2549,6 +2727,12 @@ export type GroupTimelineOptions = {
   readableTurns?: boolean;
   /** @deprecated Use readableTurns. Cross-turn exchange folding has been removed. */
   foldExchanges?: boolean;
+  /**
+   * When the session was paused ({@link timelinePauseSpans}). A readable
+   * turn still open under a pause in force reads as paused, and paused time
+   * is not counted as work.
+   */
+  pauses?: readonly TimelinePauseSpan[];
 };
 
 export function groupTimeline(
@@ -2556,7 +2740,8 @@ export function groupTimeline(
   items: TimelineItem[],
   options: GroupTimelineOptions = {},
 ): TimelineGroup[] {
-  if (options.readableTurns || options.foldExchanges) return groupReadableTurns(t, items);
+  if (options.readableTurns || options.foldExchanges)
+    return groupReadableTurns(t, items, options.pauses ?? []);
   const groups: TimelineGroup[] = [];
   for (const item of items) {
     // A recovered capacity wait is over; it leaves no warning behind.
@@ -2585,7 +2770,11 @@ export function groupTimeline(
 }
 
 /** Live prose stays primary; settled progress joins its own turn's work history. */
-function groupReadableTurns(t: OpenGeniText, items: TimelineItem[]): TimelineGroup[] {
+function groupReadableTurns(
+  t: OpenGeniText,
+  items: TimelineItem[],
+  pauses: readonly TimelinePauseSpan[],
+): TimelineGroup[] {
   type Work = Extract<TimelineGroup, { kind: "activity" }>;
   let groups: TimelineGroup[] = [];
   const turns = new Map<string, Work>();
@@ -2721,12 +2910,12 @@ function groupReadableTurns(t: OpenGeniText, items: TimelineItem[]): TimelineGro
         group.work!.details.push({ kind: "activity", id: `work-item-${item.id}`, items: [item] });
       delete group.work!.waiting;
     } else if (item.kind === "notice" && item.capacityWait) {
-      const pauses = idleSpans.get(key) ?? [];
-      pauses.push({
+      const idle = idleSpans.get(key) ?? [];
+      idle.push({
         startedAt: item.occurredAt,
         ...(item.resolvedAt ? { endedAt: item.resolvedAt } : {}),
       });
-      idleSpans.set(key, pauses);
+      idleSpans.set(key, idle);
       if (!item.resolvedAt) {
         if (settlements.has(key)) groups.push({ kind: "item", item });
         else {
@@ -2842,6 +3031,7 @@ function groupReadableTurns(t: OpenGeniText, items: TimelineItem[]): TimelineGro
                 ? t("timeline.projection.waitingForYou")
                 : t("timeline.projection.waiting"),
             since: item.occurredAt,
+            ...(item.approval === true ? { waitingOn: "you" as const } : {}),
           };
         } else if (
           item.kind === "session-status" &&
@@ -2852,6 +3042,7 @@ function groupReadableTurns(t: OpenGeniText, items: TimelineItem[]): TimelineGro
           current.waiting = {
             label: t("timeline.projection.waitingForYou"),
             since: item.occurredAt,
+            waitingOn: "you",
           };
         } else if (
           item.kind === "session-status" &&
@@ -2890,17 +3081,38 @@ function groupReadableTurns(t: OpenGeniText, items: TimelineItem[]): TimelineGro
         untimed: true,
       };
     }
-    const pausedMs = (idleSpans.get(key) ?? []).reduce((total, pause) => {
-      if (!pause.endedAt) return total;
-      const start = Math.max(Date.parse(work.startedAt), Date.parse(pause.startedAt));
-      const end = Math.min(
-        work.endedAt ? Date.parse(work.endedAt) : Number.POSITIVE_INFINITY,
-        Date.parse(pause.endedAt),
-      );
-      return Number.isFinite(start) && Number.isFinite(end) && end > start
-        ? total + end - start
-        : total;
-    }, 0);
+    const workStart = Date.parse(work.startedAt);
+    const workEnd = work.endedAt ? Date.parse(work.endedAt) : Number.POSITIVE_INFINITY;
+    // A pause still in force over this open turn: the turn is parked for
+    // Resume, so it reads as paused and its clock stops when the pause began.
+    // A wait on the person (an approval, a question) keeps saying so.
+    const openPause =
+      work.endedAt || work.waiting?.waitingOn === "you"
+        ? undefined
+        : pauses.find((pause) => !pause.endedAt && Date.parse(pause.startedAt) < workEnd);
+    const pausedAt = openPause
+      ? Math.max(workStart, Date.parse(openPause.startedAt))
+      : Number.POSITIVE_INFINITY;
+    if (openPause && Number.isFinite(pausedAt)) {
+      work.pausedAt = new Date(pausedAt).toISOString();
+      delete work.waiting;
+    }
+    // Capacity waits, failed-attempt gaps and pauses can overlap; their union
+    // is time the agent was not working. A span still open runs to the end of
+    // the work (a turn cancelled while paused) or to the pause that stopped
+    // its clock; on a turn still running it has no end yet and counts later.
+    const until = Math.min(workEnd, pausedAt);
+    const pausedMs = unionLength(
+      [...(idleSpans.get(key) ?? []), ...pauses].flatMap((span) =>
+        span.endedAt
+          ? [[Date.parse(span.startedAt), Date.parse(span.endedAt)] as const]
+          : Number.isFinite(until)
+            ? [[Date.parse(span.startedAt), until] as const]
+            : [],
+      ),
+      workStart,
+      until,
+    );
     if (pausedMs > 0) work.pausedMs = pausedMs;
   }
   groups = groups.filter((entry) => {