@opengeni/react 6.8.0 → 6.8.1-canary.41842879332001

package/src/app/lib/sessions-group.tsx

@@ -73,6 +73,7 @@ export type RailAggregateStatusKind =
   | "active"
   | "queued"
   | "waiting"
+  | "paused"
   | "unread"
   | "active_work"
   | "neutral";
@@ -103,6 +104,8 @@ export type RailStatusCounts = {
   queued: number;
   /** Idle sessions parked on their own wake-up (input or timer), not executing. */
   waiting: number;
+  /** Paused sessions whose work is parked for Resume. */
+  paused: number;
   unread: number;
   activeWork: number;
 };
@@ -122,6 +125,7 @@ export function sessionProjectTotals(
     active: 0,
     queued: 0,
     waiting: 0,
+    paused: 0,
     unread: 0,
     activeWork: 0,
   });
@@ -137,6 +141,7 @@ export function sessionProjectTotals(
       ...group,
       active: group.active - waiting,
       waiting,
+      paused: 0,
       sendFailed: 0,
     });
   }
@@ -173,11 +178,32 @@ function ownRailStatusCounts(
         ? 1
         : 0,
     waiting: sessionInputWait(session) ? 1 : 0,
+    paused: hasPausedWork(session) ? 1 : 0,
     unread: session.unread ? 1 : 0,
     activeWork: session.activelyWorking ? 1 : 0,
   };
 }
 
+/**
+ * Work a pause holds for Resume: a turn still open, queued or running. A
+ * paused chat with nothing in progress shows no marker, nor does one that
+ * needs the person or is ending (Cancel also pauses while the turn stops).
+ * Matches the server's `treeStats.pausedWorkDescendants`.
+ */
+function hasPausedWork(session: Session): boolean {
+  return (
+    !hasActiveEffectiveControl(session) &&
+    session.status !== "requires_action" &&
+    session.status !== "cancelled" &&
+    session.status !== "failed" &&
+    (Boolean(session.activeTurnId) ||
+      session.status === "running" ||
+      session.status === "recovering" ||
+      session.status === "queued" ||
+      session.status === "waiting_capacity")
+  );
+}
+
 function addRailStatusCounts(target: RailStatusCounts, source: RailStatusCounts): void {
   target.total += source.total;
   target.sendFailed += source.sendFailed;
@@ -187,6 +213,7 @@ function addRailStatusCounts(target: RailStatusCounts, source: RailStatusCounts)
   target.active += source.active;
   target.queued += source.queued;
   target.waiting += source.waiting;
+  target.paused += source.paused;
   target.unread += source.unread;
   target.activeWork += source.activeWork;
 }
@@ -211,6 +238,7 @@ function railStatusCounts(
       active: summary.active - waiting,
       queued: summary.queued,
       waiting,
+      paused: 0,
       unread: summary.unread,
       activeWork: summary.activeWork,
     };
@@ -225,6 +253,7 @@ function railStatusCounts(
       "active",
       "queued",
       "waiting",
+      "paused",
       "unread",
       "activeWork",
     ] as const)
@@ -244,6 +273,7 @@ function railStatusCounts(
     counts.active += stats.runningDescendants;
     counts.queued += stats.queuedDescendants;
     counts.waiting += stats.waitingDescendants ?? 0;
+    counts.paused += stats.pausedWorkDescendants ?? 0;
     counts.unread += stats.unreadDescendants ?? 0;
     counts.activeWork += stats.activelyWorkingDescendants ?? 0;
 
@@ -298,6 +328,7 @@ export function summarizeRailNodes(
     active: 0,
     queued: 0,
     waiting: 0,
+    paused: 0,
     unread: 0,
     activeWork: 0,
   };
@@ -318,8 +349,8 @@ export function summarizeRailNodes(
  * covers stays in its label ("1 unread · 2 working"), and an expanded row's
  * workers keep their own markers. The chat's own running or queued turn keeps
  * its spinner: progress it posts mid-turn can leave it unread, and the answer
- * arrives when that turn ends. Anything that needs you, a failure and an
- * unsent message still come first. Section headers and Site rows summarize
+ * arrives when that turn ends; its own paused turn likewise stays paused.
+ * Anything that needs you, a failure and an unsent message still come first. Section headers and Site rows summarize
  * many chats and keep the plain order.
  */
 export function summarizeRailRow(
@@ -330,10 +361,16 @@ export function summarizeRailRow(
   const counts = railStatusCounts(node, localDeliveryAttention);
   const summary = summarizeRailStatusCounts(counts, now);
   if (node.siteGroup || !node.session.unread) return summary;
-  if (summary.kind !== "active" && summary.kind !== "queued" && summary.kind !== "waiting")
+  if (
+    summary.kind !== "active" &&
+    summary.kind !== "queued" &&
+    summary.kind !== "waiting" &&
+    summary.kind !== "paused"
+  )
     return summary;
   const own = ownRailStatusCounts(node.session, localDeliveryAttention);
-  if (own.active > 0 || own.queued > 0) return summary;
+  if (own.active > 0 || own.queued > 0 || (summary.kind === "paused" && own.paused > 0))
+    return summary;
   return {
     kind: "unread",
     count: counts.unread,
@@ -402,6 +439,14 @@ export function summarizeRailStatusCounts(
       label: `${counts.waiting} waiting to resume`,
     };
   }
+  if (counts.paused > 0) {
+    return {
+      kind: "paused",
+      count: counts.paused,
+      total: counts.total,
+      label: `${counts.paused} paused`,
+    };
+  }
   if (counts.unread > 0) {
     return {
       kind: "unread",
@@ -1120,6 +1165,7 @@ type RemovedCounts = {
   waiting: number;
   attention: number;
   paused: number;
+  pausedWork: number;
   failed: number;
   unreadFailed: number;
   unread: number;
@@ -1134,6 +1180,7 @@ function emptyRemovedCounts(): RemovedCounts {
     waiting: 0,
     attention: 0,
     paused: 0,
+    pausedWork: 0,
     failed: 0,
     unreadFailed: 0,
     unread: 0,
@@ -1148,6 +1195,7 @@ function addRemovedCounts(target: RemovedCounts, source: RemovedCounts): void {
   target.waiting += source.waiting;
   target.attention += source.attention;
   target.paused += source.paused;
+  target.pausedWork += source.pausedWork;
   target.failed += source.failed;
   target.unreadFailed += source.unreadFailed;
   target.unread += source.unread;
@@ -1164,6 +1212,7 @@ function subtreeCounts(node: SessionTreeNode): RemovedCounts {
     waiting: sessionInputWait(node.session) ? 1 : 0,
     attention: awaitsPerson(node.session) ? 1 : 0,
     paused: node.session.effectiveControl?.state === "paused" ? 1 : 0,
+    pausedWork: hasPausedWork(node.session) ? 1 : 0,
     failed: status === "failed" ? 1 : 0,
     unreadFailed: status === "failed" && node.session.unread ? 1 : 0,
     unread: node.session.unread ? 1 : 0,
@@ -1177,6 +1226,7 @@ function subtreeCounts(node: SessionTreeNode): RemovedCounts {
     counts.waiting += stats.waitingDescendants ?? 0;
     counts.attention += stats.attentionDescendants;
     counts.paused += stats.pausedDescendants;
+    counts.pausedWork += stats.pausedWorkDescendants ?? 0;
     counts.failed += stats.failedDescendants;
     counts.unreadFailed += stats.unreadFailedDescendants ?? stats.failedDescendants;
     counts.unread += stats.unreadDescendants ?? 0;
@@ -1219,6 +1269,14 @@ function prunePinnedSubtreesWithCounts(
             : {}),
           attentionDescendants: Math.max(0, stats.attentionDescendants - removed.attention),
           pausedDescendants: Math.max(0, stats.pausedDescendants - removed.paused),
+          ...(stats.pausedWorkDescendants !== undefined
+            ? {
+                pausedWorkDescendants: Math.max(
+                  0,
+                  stats.pausedWorkDescendants - removed.pausedWork,
+                ),
+              }
+            : {}),
           failedDescendants: Math.max(0, stats.failedDescendants - removed.failed),
           ...(stats.unreadFailedDescendants !== undefined
             ? {

package/src/app/routes/session.tsx

@@ -4,6 +4,7 @@ import {
   createSessionRetainedScreenshotLoader,
   createWorkspaceRetainedArtifactLoader,
   createWorkspaceRetainedVideoLoader,
+  timelineLivePause,
 } from "../../timeline";
 import { isModelUnavailableSubmissionError, type CreditRefusalKind } from "../../lib/format";
 import { inertProps } from "../../lib/inert";
@@ -4253,6 +4254,7 @@ function SessionChatPane(props: {
                           focusSequence={momentSequence}
                           events={props.events}
                           status={props.session.status}
+                          pause={timelineLivePause(admissionControl)}
                           computeLabel={computeLabel}
                           renderMessageText={renderMessageText}
                           renderMessageActions={renderMessageActions}

package/src/components/message-timeline.tsx

@@ -25,6 +25,7 @@ import {
   type TimelineSearchTarget,
 } from "./timeline-search";
 import { GenieLoadingOptionsContext, type GenieLoadingOptions } from "../timeline/genie-loading";
+import { useTimelinePauses } from "../timeline/use-timeline-pauses";
 import { ChildSessionLink } from "./child-session-link";
 import { useStartupDetails } from "../timeline/startup-preference";
 import {
@@ -133,6 +134,7 @@ import {
   defaultToolRegistry,
   groupTimeline,
   LightboxProvider,
+  type TimelineLivePause,
   type ActivityItem,
   type AgentMessageItem,
   type AuthNeededItem,
@@ -235,6 +237,14 @@ export type MessageTimelineProps = {
   items?: TimelineItem[] | undefined;
   /** Current session status (reserved; tip "Working…" chrome removed for now). */
   status?: SessionStatus | null | undefined;
+  /**
+   * The session's live Pause, from its effective control
+   * (`timelineLivePause(session.effectiveControl)`). A turn still open under a
+   * pause reads "Paused" with its clock stopped, and paused time is not
+   * counted as work. Omit to rely on the session's events alone, which do not
+   * show a pause of an ancestor or the workspace that interrupted nothing.
+   */
+  pause?: TimelineLivePause | null | undefined;
   /** Host-owned controls beside Copy and the timestamp on settled message rows. */
   renderMessageActions?: ((item: AgentMessageItem | UserMessageItem) => ReactNode) | undefined;
   /**
@@ -651,6 +661,7 @@ export function MessageTimeline({
   events,
   items,
   status: _status,
+  pause,
   renderMessageActions,
   renderMessageSender,
   renderMessageText,
@@ -820,9 +831,10 @@ export function MessageTimeline({
   const olderPageBudgetRef = useRef(0);
   const [olderDemand, setOlderDemand] = useState(0);
   const readableTurns = turnSummary?.rolling === true;
+  const pauses = useTimelinePauses(events, pause, readableTurns);
   const projectedGroups = useMemo(
-    () => groupTimeline(t, resolvedItems, { readableTurns }),
-    [resolvedItems, readableTurns, t],
+    () => groupTimeline(t, resolvedItems, { readableTurns, pauses }),
+    [resolvedItems, readableTurns, pauses, t],
   );
   // A new timeline revision (including session/turn replacement) owns layout.
   // Never leave an old decorative transform running on its retained rows.

package/src/components/session-conversation.tsx

@@ -61,7 +61,7 @@ import {
 } from "./conversation-capability-connect";
 import type { SessionMcpCapabilityCardProps } from "./session-mcp-capability-card";
 import type { SessionIntegrationCapabilityCardProps } from "./session-integration-capability-card";
-import type { AuthNeededItem } from "../timeline";
+import { timelineLivePause, type AuthNeededItem } from "../timeline";
 import { ProviderRecoveryNotice } from "./provider-recovery-notice";
 import { currentProviderRecovery } from "../lib/provider-recovery";
 import {
@@ -718,6 +718,7 @@ function ConversationView({
               emptyState={timelineProps?.emptyState}
               renderMessageSender={timelineProps?.renderMessageSender}
               status={status}
+              pause={timelineLivePause(voiceControl)}
               hasOlder={feed.hasOlder}
               loadingOlder={feed.loadingOlder}
               onLoadOlder={feed.loadOlder}

package/src/components/timeline-annotations.tsx

@@ -74,8 +74,11 @@ export function TimelineAnnotationCards({
       data-og-annotation-cards=""
       className={cn(
         "grid gap-2",
+        // Inside the timeline, let the wheel chain to the timeline once this
+        // stack is at its edge. Containing overscroll here made the whole
+        // message a dead zone for scrolling, even when the stack fit.
         annotations.length >= ANNOTATION_CARD_STACK_SCROLL_AT &&
-          "max-h-[min(28rem,55vh)] overflow-x-hidden overflow-y-auto overscroll-contain pr-1",
+          "max-h-[min(28rem,55vh)] overflow-x-hidden overflow-y-auto pr-1",
         className,
       )}
     >

package/src/components/timeline-settlement.ts

@@ -14,7 +14,7 @@ export function captureTimelineSettlement(
   if (timelineHasReader(scroller)) return null;
   const live = Array.from(
     scroller.querySelectorAll(
-      '[data-og-exchange-status="working"], [data-og-exchange-status="waiting"]',
+      '[data-og-exchange-status="working"], [data-og-exchange-status="waiting"], [data-og-exchange-status="paused"]',
     ),
   );
   // At the live tip the newest retained answer owns the transition. An older

package/src/hooks/use-recordings.ts

@@ -9,6 +9,7 @@ import type {
   RecordingPerson,
   RecordingVoiceprintConsent,
   RecordingSpeaker,
+  RecordingCalendarEventRef,
   RecordingTranscriptionRequest,
   RecordingTranscriptPage,
   RecordingTranscriptSegment,
@@ -172,6 +173,8 @@ export type UseRecorderOptions = RecordingsClientOverride & {
   /** Your own id for what this recording belongs to, to find it again with `useRecordings`. */
   externalRef?: string;
   metadata?: Record<string, unknown>;
+  /** The owner's calendar event the meeting is of, such as one they joined; it names the meeting. */
+  calendarEvent?: RecordingCalendarEventRef;
   transcription?: RecordingTranscriptionRequest;
   /**
    * The person recording's name, as your app knows it: their microphone's
@@ -241,6 +244,7 @@ export type UseRecorderResult = RecorderSnapshot & {
       | "transcription"
       | "externalRef"
       | "metadata"
+      | "calendarEvent"
       | "ownerName"
     >,
   ) => Promise<void>;
@@ -473,6 +477,7 @@ export function useRecorder(options: UseRecorderOptions = {}): UseRecorderResult
         ...(merged.visibility ? { visibility: merged.visibility } : {}),
         ...(merged.externalRef ? { externalRef: merged.externalRef } : {}),
         ...(merged.metadata ? { metadata: merged.metadata as never } : {}),
+        ...(merged.calendarEvent ? { calendarEvent: merged.calendarEvent } : {}),
         ...(merged.transcription ? { transcription: merged.transcription } : {}),
         ...(merged.ownerName?.trim() ? { ownerName: merged.ownerName } : {}),
         ...(merged.microphone !== undefined ? { microphone: merged.microphone } : {}),

package/src/index.ts

@@ -481,10 +481,15 @@ export {
   extractSessionRef,
   groupTimeline,
   sessionStatusFromEvents,
+  timelineLivePause,
+  timelinePauseSpans,
   toolDisplayName,
+  useTimelinePauses,
 } from "./timeline";
 export type {
   GroupTimelineOptions,
+  TimelineLivePause,
+  TimelinePauseSpan,
   ActivityItem,
   AgentMessageItem,
   AuthNeededItem,

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

@@ -3740,6 +3740,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 +6082,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/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 {