@startsimpli/integrations 0.2.47 → 0.2.49

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@startsimpli/integrations",
-  "version": "0.2.47",
+  "version": "0.2.49",
   "description": "Provider-agnostic types, API clients, hooks, and UI primitives for email + calendar integrations across StartSimpli apps, plus foundry customer email (subpath ./comms).",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -35,7 +35,7 @@
     "react": ">=18.0.0",
     "@tanstack/react-query": ">=5.0.0",
     "@startsimpli/llm": ">=0.4.0",
-    "@startsimpli/ui": "^0.4.162"
+    "@startsimpli/ui": "^0.4.163"
   },
   "peerDependenciesMeta": {
     "react": {
@@ -65,7 +65,7 @@
     "typescript": "^6.0.0",
     "vitest": "^3.0.0",
     "@startsimpli/llm": "0.4.25",
-    "@startsimpli/ui": "0.4.162"
+    "@startsimpli/ui": "0.4.163"
   },
   "scripts": {
     "type-check": "tsc --noEmit",

package/src/comms/__tests__/announcement-composer.test.tsx

@@ -41,7 +41,8 @@ const server = setupServer(
     if (hit.path === '/programs/') return HttpResponse.json([comeback(), productUpdate()]);
     if (hit.path === '/drafts/' && hit.method === 'POST') return createReply();
     if (hit.path === '/drafts/') {
-      const results = drafts.filter((d) => d.approval === 'pending');
+      const wanted = url.searchParams.get('status') ?? 'pending';
+      const results = drafts.filter((d) => d.approval === wanted);
       return HttpResponse.json({ count: results.length, next: null, previous: null, results });
     }
     const m = hit.path.match(/^\/drafts\/([^/]+)\/$/);

package/src/comms/__tests__/scheduled-send.test.tsx

@@ -0,0 +1,304 @@
+/**
+ * Scheduled and cancellable sends (bd startsim-yzivy): schedule a pending draft,
+ * see it listed with its send time, reschedule / send now / cancel it, and see
+ * scheduled and cancelled drafts in the send log. A mocked Django (msw) behind
+ * the REAL createCommsApi client, so each test is click -> request -> render.
+ */
+import * as React from 'react';
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from 'vitest';
+import { fireEvent, render, screen, waitFor, within } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { http, HttpResponse } from 'msw';
+import { setupServer } from 'msw/node';
+
+import { DraftReview } from '../components/DraftReview';
+import { SendLog } from '../components/SendLog';
+import { createCommsApi, setApiBase } from '../api/index';
+import type { Draft, ScheduledSend } from '../types/index';
+import { BASE, P, SLUG, draft } from './fixtures';
+
+interface Hit { method: string; path: string; body: any }
+let hits: Hit[] = [];
+let drafts: Draft[] = [];
+let scheduledReport: ScheduledSend[] = [];
+let conflict = false;
+let liveCount = 2;
+
+const rel = (p: string) => p.replace(new URL(P).pathname, '');
+
+const server = setupServer(
+  http.all(`${P}/*`, async ({ request }) => {
+    const url = new URL(request.url);
+    const text = request.method === 'GET' ? '' : await request.text();
+    const hit: Hit = { method: request.method, path: rel(url.pathname), body: text ? JSON.parse(text) : undefined };
+    hits.push(hit);
+    const { method, path, body } = hit;
+    let m: RegExpMatchArray | null;
+    if (path === '/drafts/' && method === 'GET') {
+      const wanted = url.searchParams.get('status');
+      const results = drafts.filter((d) => !wanted || d.approval === wanted);
+      return HttpResponse.json({ count: results.length, next: null, previous: null, results });
+    }
+    if ((m = path.match(/^\/drafts\/([\w-]+)\/(approve|reschedule|cancel)\/$/)) && method === 'POST') {
+      const d = drafts.find((x) => x.id === m![1])!;
+      if (conflict) return HttpResponse.json({ detail: 'the send has already started and cannot be cancelled' }, { status: 409 });
+      if (m[2] === 'approve') {
+        if (body?.send_at && body.send_at < '2026-01-01') Object.assign(d, { approval: 'approved', state: 'sending', sent_immediately: true, requested_send_at: '2020-01-01T00:00:00+00:00' });
+        else if (body?.send_at) Object.assign(d, { approval: 'scheduled', send_at: '2026-11-03T15:00:00+00:00', send_timezone: body.timezone ?? null });
+        else d.approval = 'approved';
+      } else if (m[2] === 'reschedule') {
+        Object.assign(d, { send_at: '2026-11-05T15:00:00+00:00', send_timezone: body.timezone ?? null });
+      } else {
+        Object.assign(d, { approval: 'pending', send_at: null, send_timezone: null, cancelled_at: '2026-11-01T09:00:00+00:00' });
+      }
+      return HttpResponse.json(d);
+    }
+    if ((m = path.match(/^\/drafts\/([\w-]+)\/retry\/$/)) && method === 'POST') {
+      const d = drafts.find((x) => x.id === m![1])!;
+      Object.assign(d, { approval: 'approved', state: 'sending', failure: null, next_actions: ['wait'] });
+      return HttpResponse.json(d);
+    }
+    if ((m = path.match(/^\/drafts\/([\w-]+)\/audience\/$/)) && method === 'GET') {
+      return HttpResponse.json({ audience: { base: 'all' }, is_default: true, preview: { count: liveCount, eligible: liveCount, excluded: {}, excluded_total: 0, sample: [], excluded_sample: [] } });
+    }
+    if (path === '/sends/' && method === 'GET') {
+      return HttpResponse.json({ count: 0, next: null, previous: null, results: [], scheduled: scheduledReport });
+    }
+    return HttpResponse.json({ detail: `unhandled ${method} ${path}` }, { status: 599 });
+  }),
+);
+
+beforeAll(() => {
+  server.listen({ onUnhandledRequest: 'error' });
+  setApiBase(`${BASE}/api/v1`);
+});
+afterEach(() => server.resetHandlers());
+afterAll(() => server.close());
+beforeEach(() => {
+  hits = [];
+  drafts = [draft()];
+  scheduledReport = [];
+  conflict = false;
+  liveCount = 2;
+});
+
+function renderWith(node: (api: ReturnType<typeof createCommsApi>) => React.ReactElement) {
+  const qc = new QueryClient({ defaultOptions: { queries: { retry: false }, mutations: { retry: false } } });
+  return render(<QueryClientProvider client={qc}>{node(createCommsApi(SLUG))}</QueryClientProvider>);
+}
+
+const writes = () => hits.filter((h) => h.method !== 'GET');
+
+async function schedule(when = '2026-11-03T10:00', zone = 'Asia/Tokyo') {
+  await userEvent.click(await screen.findByRole('button', { name: /schedule/i }));
+  fireEvent.change(screen.getByLabelText('Send at'), { target: { value: when } });
+  await userEvent.selectOptions(screen.getByLabelText('Time zone'), zone);
+  await userEvent.click(screen.getByRole('button', { name: /approve and schedule/i }));
+}
+
+describe('scheduling a pending draft', () => {
+  it('Approve and send still sends now, with no schedule on the wire', async () => {
+    renderWith((api) => <DraftReview api={api} pollIntervalMs={10} />);
+    await userEvent.click(await screen.findByRole('button', { name: /approve and send/i }));
+    await waitFor(() => expect(writes()[0]).toMatchObject({ method: 'POST', path: '/drafts/d-1/approve/' }));
+    expect(writes()[0].body).toBeUndefined();
+  });
+
+  it('posts the local time with its zone, then lists the draft as scheduled', async () => {
+    renderWith((api) => <DraftReview api={api} pollIntervalMs={10} />);
+    await schedule();
+    await waitFor(() =>
+      expect(writes()[0]).toMatchObject({
+        method: 'POST', path: '/drafts/d-1/approve/', body: { send_at: '2026-11-03T10:00', timezone: 'Asia/Tokyo' },
+      }),
+    );
+    const heading = await screen.findByRole('heading', { name: /scheduled to send/i });
+    const list = heading.parentElement as HTMLElement;
+    expect(await within(list).findByText('New: stitch counter')).toBeInTheDocument();
+    expect(within(list).getByText(/^Sends /)).toBeInTheDocument();
+    // it left the waiting-for-approval list
+    expect(screen.queryByRole('button', { name: /approve and send/i })).toBeNull();
+  });
+
+  it('makes no write until the form is submitted', async () => {
+    renderWith((api) => <DraftReview api={api} pollIntervalMs={10} />);
+    await userEvent.click(await screen.findByRole('button', { name: /schedule/i }));
+    expect(screen.getByRole('button', { name: /approve and schedule/i })).toBeDisabled(); // no time yet
+    expect(writes()).toEqual([]);
+  });
+
+  it('shows the server reason when scheduling is refused', async () => {
+    conflict = true;
+    renderWith((api) => <DraftReview api={api} pollIntervalMs={10} />);
+    await schedule();
+    expect((await screen.findByRole('alert')).textContent).toMatch(/already started/i);
+  });
+});
+
+describe('a scheduled draft', () => {
+  beforeEach(() => {
+    drafts = [draft({ approval: 'scheduled', send_at: '2026-11-03T15:00:00+00:00', send_timezone: 'America/New_York' })];
+  });
+
+  it('is listed with its send time, in the zone it was set in', async () => {
+    renderWith((api) => <DraftReview api={api} pollIntervalMs={10} />);
+    expect(await screen.findByRole('heading', { name: /scheduled to send/i })).toBeInTheDocument();
+    expect(await screen.findByText(/^Sends .*(10:00|11:00)/)).toBeInTheDocument();
+    expect(screen.getByText('No updates are waiting for approval.')).toBeInTheDocument();
+  });
+
+  it('cancels the schedule and the draft is waiting for approval again', async () => {
+    renderWith((api) => <DraftReview api={api} pollIntervalMs={10} />);
+    await userEvent.click(await screen.findByRole('button', { name: /cancel schedule/i }));
+    await waitFor(() => expect(writes()[0]).toMatchObject({ method: 'POST', path: '/drafts/d-1/cancel/' }));
+    expect(await screen.findByRole('button', { name: /approve and send/i })).toBeInTheDocument();
+    expect(await screen.findByText(/schedule cancelled/i)).toBeInTheDocument();
+  });
+
+  it('reschedules with a new time and zone', async () => {
+    renderWith((api) => <DraftReview api={api} pollIntervalMs={10} />);
+    await userEvent.click(await screen.findByRole('button', { name: /^reschedule$/i }));
+    fireEvent.change(screen.getByLabelText('Send at'), { target: { value: '2026-11-05T10:00' } });
+    await userEvent.selectOptions(screen.getByLabelText('Time zone'), 'UTC');
+    await userEvent.click(screen.getByRole('button', { name: /move send/i }));
+    await waitFor(() =>
+      expect(writes()[0]).toMatchObject({
+        method: 'POST', path: '/drafts/d-1/reschedule/', body: { send_at: '2026-11-05T10:00', timezone: 'UTC' },
+      }),
+    );
+  });
+
+  it('sends now', async () => {
+    renderWith((api) => <DraftReview api={api} pollIntervalMs={10} />);
+    await userEvent.click(await screen.findByRole('button', { name: /^send now$/i }));
+    await waitFor(() => expect(writes()[0]).toMatchObject({ method: 'POST', path: '/drafts/d-1/approve/' }));
+    expect(writes()[0].body).toBeUndefined();
+  });
+
+  it('shows the server reason when cancel is too late', async () => {
+    conflict = true;
+    renderWith((api) => <DraftReview api={api} pollIntervalMs={10} />);
+    await userEvent.click(await screen.findByRole('button', { name: /cancel schedule/i }));
+    expect((await screen.findByRole('alert')).textContent).toMatch(/already started/i);
+  });
+});
+
+describe('send log', () => {
+  it('lists scheduled and cancelled drafts above the sent rows', async () => {
+    scheduledReport = [
+      { id: 's-1', program_key: 'product_update', subject: 'Tuesday news', status: 'scheduled',
+        send_at: '2026-11-03T15:00:00+00:00', send_timezone: 'UTC', cancelled_at: null },
+      { id: 's-2', program_key: 'announcement', subject: 'Dropped idea', status: 'cancelled',
+        send_at: null, send_timezone: null, cancelled_at: '2026-11-01T09:00:00+00:00' },
+    ];
+    renderWith((api) => <SendLog api={api} />);
+    const heading = await screen.findByRole('heading', { name: /scheduled and cancelled/i });
+    const table = within(heading.parentElement as HTMLElement);
+    expect(table.getByText('Tuesday news')).toBeInTheDocument();
+    expect(table.getByText('scheduled')).toBeInTheDocument();
+    expect(table.getByText('Dropped idea')).toBeInTheDocument();
+    expect(table.getByText('cancelled')).toBeInTheDocument();
+    expect(table.getByText(/^Cancelled /)).toBeInTheDocument();
+  });
+
+  it('shows no scheduled section when there is nothing scheduled', async () => {
+    renderWith((api) => <SendLog api={api} />);
+    expect(await screen.findByText(/no emails sent yet/i)).toBeInTheDocument();
+    expect(screen.queryByRole('heading', { name: /scheduled and cancelled/i })).toBeNull();
+  });
+});
+
+// ---- the closed loop: every state is named, with a reason and a next action ----
+
+describe('states the admin has to act on', () => {
+  it('says when a past time was sent immediately', async () => {
+    renderWith((api) => <DraftReview api={api} pollIntervalMs={10} />);
+    await schedule('2020-01-01T10:00', 'UTC');
+    expect(await screen.findByText(/sent immediately/i)).toBeInTheDocument();
+    expect(screen.getByText(/had already passed/i)).toBeInTheDocument();
+  });
+
+  it('explains the picker: a time that has passed sends now', async () => {
+    renderWith((api) => <DraftReview api={api} pollIntervalMs={10} />);
+    await userEvent.click(await screen.findByRole('button', { name: /schedule/i }));
+    expect(screen.getByText(/already passed sends immediately/i)).toBeInTheDocument();
+  });
+
+  it('shows an expired send with its reason and original time, and can approve again', async () => {
+    drafts = [draft({
+      approval: 'expired', state: 'expired', next_actions: ['approve', 'schedule', 'edit', 'discard'],
+      notice: { code: 'expired', reason: 'comms were paused at the scheduled time', send_at: '2026-11-03T15:00:00+00:00' },
+    })];
+    renderWith((api) => <DraftReview api={api} pollIntervalMs={10} />);
+    const heading = await screen.findByRole('heading', { name: /needs attention/i });
+    const area = within(heading.parentElement as HTMLElement);
+    expect(await area.findByText(/comms were paused at the scheduled time/i)).toBeInTheDocument();
+    expect(area.getByText(/was scheduled for/i)).toBeInTheDocument();
+    await userEvent.click(area.getByRole('button', { name: /approve and send/i }));
+    await waitFor(() => expect(writes()[0]).toMatchObject({ method: 'POST', path: '/drafts/d-1/approve/' }));
+  });
+
+  it('shows a failed send with the error and a Retry that posts retry', async () => {
+    drafts = [draft({
+      approval: 'failed', state: 'failed', next_actions: ['retry', 'approve', 'discard'],
+      failure: { stage: 'dispatch', code: 'audience_unavailable', reason: 'could not reach the foundry backend (after 3 attempts)', at: '2026-11-03T15:01:00+00:00' },
+    })];
+    renderWith((api) => <DraftReview api={api} pollIntervalMs={10} />);
+    expect(await screen.findByText(/could not reach the foundry backend/i)).toBeInTheDocument();
+    await userEvent.click(screen.getByRole('button', { name: /^retry$/i }));
+    await waitFor(() => expect(writes()[0]).toMatchObject({ method: 'POST', path: '/drafts/d-1/retry/' }));
+  });
+
+  it('a send that failed after it started offers only Retry', async () => {
+    drafts = [draft({
+      approval: 'failed', state: 'failed', next_actions: ['retry'],
+      failure: { stage: 'send', code: 'recipients_not_sent', reason: '2 recipients were still unsent after 3 retries', at: '2026-11-03T15:01:00+00:00' },
+    })];
+    renderWith((api) => <DraftReview api={api} pollIntervalMs={10} />);
+    expect(await screen.findByText(/2 recipients were still unsent/i)).toBeInTheDocument();
+    expect(screen.getByRole('button', { name: /^retry$/i })).toBeInTheDocument();
+    expect(screen.queryByRole('button', { name: /approve and send/i })).toBeNull();
+    expect(screen.queryByRole('button', { name: /^discard$/i })).toBeNull();
+  });
+
+  it('shows why an auto-approved draft is still waiting', async () => {
+    drafts = [draft({ notice: { code: 'no_recipients', reason: 'this audience has no recipients (2 opted out)' } })];
+    renderWith((api) => <DraftReview api={api} pollIntervalMs={10} />);
+    expect(await screen.findByText(/no recipients \(2 opted out\)/i)).toBeInTheDocument();
+  });
+
+  it('shows a scheduled send that is being retried', async () => {
+    drafts = [draft({
+      approval: 'scheduled', send_at: '2026-11-03T15:00:00+00:00', send_timezone: 'UTC',
+      dispatch_attempts: 1, dispatch_error: 'could not reach the foundry backend',
+    })];
+    renderWith((api) => <DraftReview api={api} pollIntervalMs={10} />);
+    expect(await screen.findByText(/trying again.*could not reach the foundry backend/i)).toBeInTheDocument();
+  });
+
+  it('shows both recipient counts when the audience changed since scheduling', async () => {
+    liveCount = 5;
+    drafts = [draft({ approval: 'scheduled', send_at: '2026-11-03T15:00:00+00:00', send_timezone: 'UTC', recipient_count: 2 })];
+    renderWith((api) => <DraftReview api={api} pollIntervalMs={10} />);
+    expect(await screen.findByText(/2 recipients when scheduled, 5 now/i)).toBeInTheDocument();
+  });
+
+  it('shows one count when nothing changed', async () => {
+    drafts = [draft({ approval: 'scheduled', send_at: '2026-11-03T15:00:00+00:00', send_timezone: 'UTC', recipient_count: 2 })];
+    renderWith((api) => <DraftReview api={api} pollIntervalMs={10} />);
+    expect(await screen.findByText(/^2 recipients$/i)).toBeInTheDocument();
+  });
+
+  it('the send log gives the reason for expired and failed drafts', async () => {
+    scheduledReport = [
+      { id: 'e-1', program_key: 'announcement', subject: 'Paused one', status: 'expired', reason: 'comms were paused at the scheduled time',
+        send_at: '2026-11-03T15:00:00+00:00', send_timezone: null, cancelled_at: null },
+      { id: 'f-1', program_key: 'announcement', subject: 'Broken one', status: 'failed', reason: 'this audience has no recipients',
+        send_at: null, send_timezone: null, cancelled_at: null },
+    ];
+    renderWith((api) => <SendLog api={api} />);
+    expect(await screen.findByText('comms were paused at the scheduled time')).toBeInTheDocument();
+    expect(screen.getByText('this audience has no recipients')).toBeInTheDocument();
+  });
+});

package/src/comms/api/comms.ts

@@ -34,7 +34,8 @@ import type {
   ProgramUpdateResult,
   RenderedEmail,
   SendNowResult,
-  SendRow,
+  SendsPage,
+  ScheduleInput,
   SendsQuery,
   StepGeneration,
   TestSendInput,
@@ -76,7 +77,14 @@ export interface CommsApi {
   uploadAsset(file: File, alt: string): Promise<CommsAsset>;
   deleteAsset(id: string): Promise<void>;
   updateDraft(id: string, patch: DraftPatch): Promise<Draft>;
-  approveDraft(id: string): Promise<Draft>;
+  /** Without `schedule` the send is queued now; with it the draft is scheduled (status 'scheduled'). */
+  approveDraft(id: string, schedule?: ScheduleInput): Promise<Draft>;
+  /** Move a still-scheduled draft; 409 once the send has started. */
+  rescheduleDraft(id: string, schedule: ScheduleInput): Promise<Draft>;
+  /** Scheduled -> pending again; 409 once the send has started. */
+  cancelDraft(id: string): Promise<Draft>;
+  /** Resume a failed draft (re-run the dispatch, or re-queue the unsent recipients). */
+  retryDraft(id: string): Promise<Draft>;
   discardDraft(id: string): Promise<Draft>;
   previewDraft(id: string): Promise<RenderedEmail>;
   // per-send audience: the draft's own spec (or the program default) + who it reaches
@@ -87,7 +95,7 @@ export interface CommsApi {
   sendUpdateNow(input?: { notes?: string }): Promise<SendNowResult>;
 
   // results
-  listSends(query?: SendsQuery): Promise<Paginated<SendRow>>;
+  listSends(query?: SendsQuery): Promise<SendsPage>;
   getMetrics(query?: MetricsQuery): Promise<CommsMetrics>;
 }
 
@@ -134,7 +142,11 @@ export function createCommsApi(slug: string): CommsApi {
     },
     deleteAsset: (id) => request(`${P}/assets/${seg(id)}/`, { method: 'DELETE' }),
     updateDraft: (id, patch) => request(draftPath(id), { method: 'PATCH', body: patch }),
-    approveDraft: (id) => request(draftPath(id, 'approve'), { method: 'POST' }),
+    approveDraft: (id, schedule) =>
+      request(draftPath(id, 'approve'), schedule ? { method: 'POST', body: schedule } : { method: 'POST' }),
+    rescheduleDraft: (id, schedule) => request(draftPath(id, 'reschedule'), { method: 'POST', body: schedule }),
+    cancelDraft: (id) => request(draftPath(id, 'cancel'), { method: 'POST' }),
+    retryDraft: (id) => request(draftPath(id, 'retry'), { method: 'POST' }),
     discardDraft: (id) => request(draftPath(id, 'discard'), { method: 'POST' }),
     previewDraft: (id) => request(draftPath(id, 'preview')),
     getDraftAudience: (id) => request(draftPath(id, 'audience')),

package/src/comms/components/DraftReview.tsx

@@ -14,15 +14,18 @@ import {
   DEFAULT_POLL_MS,
   useApproveDraft,
   useDiscardDraft,
+  useRetryDraft,
   useDraftPreview,
   useDrafts,
   useSendTest,
   useUpdateDraft,
 } from '../hooks/index';
-import type { Draft, DraftPatch } from '../types/index';
+import type { Draft, DraftAction, DraftPatch } from '../types/index';
 import { AudiencePanel } from './AudiencePanel';
 import { EmailPreview } from './EmailPreview';
-import { ErrorNotice, Note, formatDate, humanize, useFieldId } from './_shared';
+import { SchedulePicker } from './SchedulePicker';
+import { ScheduledSends } from './ScheduledSends';
+import { ErrorNotice, Note, formatDate, formatDateTime, humanize, useFieldId } from './_shared';
 
 export interface DraftReviewProps {
   api: CommsApi;
@@ -79,15 +82,36 @@ function DraftEditor({ api, draft, onDone }: { api: CommsApi; draft: Draft; onDo
   );
 }
 
-function DraftItem({ api, draft }: { api: CommsApi; draft: Draft }) {
+/** The actions the server says are open; older servers send none, which means the pending set. */
+function allowed(draft: Draft, action: DraftAction): boolean {
+  if (!draft.next_actions) return action !== 'retry';
+  return draft.next_actions.includes(action);
+}
+
+export function DraftItem({
+  api,
+  draft,
+  onSentImmediately,
+}: {
+  api: CommsApi;
+  draft: Draft;
+  onSentImmediately?: (draft: Draft) => void;
+}) {
   const [editing, setEditing] = useState(false);
   const [previewing, setPreviewing] = useState(false);
   const [auditing, setAuditing] = useState(false);
+  const [scheduling, setScheduling] = useState(false);
   const ready = !draft.generating && !draft.error;
   const preview = useDraftPreview(api, draft.id, previewing && ready);
   const sendTest = useSendTest(api);
   const approve = useApproveDraft(api);
   const discard = useDiscardDraft(api);
+  const retry = useRetryDraft(api);
+  const approveWith = (vars: Parameters<typeof approve.mutateAsync>[0], done?: () => void) =>
+    approve.mutateAsync(vars).then((d) => {
+      if (d.sent_immediately) onSentImmediately?.(d);
+      done?.();
+    }, () => undefined);
 
   return (
     <li className="py-3">
@@ -100,16 +124,20 @@ function DraftItem({ api, draft }: { api: CommsApi; draft: Draft }) {
           {ready ? (
             <>
               <Button type="button" size="sm" variant="outline" onClick={() => setPreviewing((v) => !v)}>Preview</Button>
-              <Button type="button" size="sm" variant="outline" onClick={() => setEditing((v) => !v)}>Edit</Button>
-              <Button
-                type="button"
-                size="sm"
-                variant="outline"
-                aria-expanded={auditing}
-                onClick={() => setAuditing((v) => !v)}
-              >
-                Audience
-              </Button>
+              {allowed(draft, 'edit') ? (
+                <>
+                  <Button type="button" size="sm" variant="outline" onClick={() => setEditing((v) => !v)}>Edit</Button>
+                  <Button
+                    type="button"
+                    size="sm"
+                    variant="outline"
+                    aria-expanded={auditing}
+                    onClick={() => setAuditing((v) => !v)}
+                  >
+                    Audience
+                  </Button>
+                </>
+              ) : null}
               <Button
                 type="button"
                 size="sm"
@@ -119,12 +147,24 @@ function DraftItem({ api, draft }: { api: CommsApi; draft: Draft }) {
               >
                 Send test to me
               </Button>
-              <Button type="button" size="sm" disabled={approve.isPending} onClick={() => approve.mutate(draft.id)}>
-                Approve and send
-              </Button>
+              {allowed(draft, 'approve') ? (
+                <Button type="button" size="sm" disabled={approve.isPending} onClick={() => approveWith(draft.id)}>
+                  Approve and send
+                </Button>
+              ) : null}
+              {allowed(draft, 'schedule') ? (
+                <Button type="button" size="sm" variant="outline" onClick={() => setScheduling((v) => !v)}>
+                  Schedule…
+                </Button>
+              ) : null}
+              {allowed(draft, 'retry') ? (
+                <Button type="button" size="sm" disabled={retry.isPending} onClick={() => retry.mutate(draft.id)}>
+                  Retry
+                </Button>
+              ) : null}
             </>
           ) : null}
-          {!draft.generating ? (
+          {!draft.generating && allowed(draft, 'discard') ? (
             <Button type="button" size="sm" variant="ghost" disabled={discard.isPending} onClick={() => discard.mutate(draft.id)}>
               Discard
             </Button>
@@ -136,39 +176,100 @@ function DraftItem({ api, draft }: { api: CommsApi; draft: Draft }) {
       {sendTest.data && !sendTest.data.sent ? (
         <ErrorNotice error={new Error(`Test not sent: ${humanize(sendTest.data.reason || 'refused')}`)} />
       ) : null}
-      <ErrorNotice error={sendTest.error ?? approve.error ?? discard.error ?? preview.error} />
+      {draft.failure ? <ErrorNotice error={new Error(`Send failed: ${draft.failure.reason}`)} /> : null}
+      {draft.notice ? (
+        <Note>
+          {draft.notice.code === 'expired' && draft.notice.send_at
+            ? `${draft.notice.reason}. It was scheduled for ${formatDateTime(draft.notice.send_at)}.`
+            : draft.notice.reason}
+        </Note>
+      ) : null}
+      <ErrorNotice error={sendTest.error ?? approve.error ?? discard.error ?? retry.error ?? preview.error} />
       {editing && ready ? <DraftEditor api={api} draft={draft} onDone={() => setEditing(false)} /> : null}
       {auditing && ready ? <AudiencePanel api={api} draftId={draft.id} /> : null}
       {previewing && preview.data ? <EmailPreview email={preview.data} /> : null}
+      {scheduling && ready ? (
+        <SchedulePicker
+          submitLabel="Approve and schedule"
+          pending={approve.isPending}
+          onCancel={() => setScheduling(false)}
+          onSubmit={(s) => approveWith({ id: draft.id, ...s }, () => setScheduling(false))}
+        />
+      ) : null}
+      {draft.cancelled_at ? <Note>{`Schedule cancelled ${formatDateTime(draft.cancelled_at)}.`}</Note> : null}
     </li>
   );
 }
 
+/** Expired and failed drafts: each states why and offers its next action. */
+function NeedsAttention({ api, pollIntervalMs, onSentImmediately }: {
+  api: CommsApi;
+  pollIntervalMs: number;
+  onSentImmediately: (draft: Draft) => void;
+}): ReactElement | null {
+  const expired = useDrafts(api, { status: 'expired', page: 1, page_size: 50 }, pollIntervalMs);
+  const failed = useDrafts(api, { status: 'failed', page: 1, page_size: 50 }, pollIntervalMs);
+  const rows = [...(failed.data?.results ?? []), ...(expired.data?.results ?? [])];
+  if (!rows.length) return null;
+  return (
+    <div className="space-y-1">
+      <h3 className="text-sm font-medium">Needs attention</h3>
+      <ul className="divide-y">
+        {rows.map((d) => (
+          <DraftItem key={d.id} api={api} draft={d} onSentImmediately={onSentImmediately} />
+        ))}
+      </ul>
+    </div>
+  );
+}
+
 export function DraftReview({ api, pollIntervalMs = DEFAULT_POLL_MS, pageSize = 10 }: DraftReviewProps): ReactElement | null {
   const [page, setPage] = useState(1);
+  const [justSent, setJustSent] = useState<Draft | null>(null);
   const drafts = useDrafts(api, { status: 'pending', page, page_size: pageSize }, pollIntervalMs);
   if (drafts.error) return <ErrorNotice error={drafts.error} />;
   if (!drafts.data) return null;
   const { results, count } = drafts.data;
-  if (!results.length) return <Note>No updates are waiting for approval.</Note>;
-  return (
-    <div className="space-y-1">
-      <h3 className="text-sm font-medium">Waiting for approval</h3>
-      <ul className="divide-y">
-        {results.map((d) => (
-          <DraftItem key={d.id} api={api} draft={d} />
-        ))}
-      </ul>
-      {count > pageSize ? (
-        <div className="flex items-center gap-2 text-sm">
-          <Button type="button" size="sm" variant="outline" disabled={!drafts.data.previous} onClick={() => setPage(page - 1)}>
-            Previous
-          </Button>
-          <Button type="button" size="sm" variant="outline" disabled={!drafts.data.next} onClick={() => setPage(page + 1)}>
-            Next
-          </Button>
-        </div>
+  const extras = (
+    <>
+      {justSent ? (
+        <Note>
+          {`"${justSent.subject}" was sent immediately: the requested time (${formatDateTime(justSent.requested_send_at)}) had already passed.`}
+        </Note>
       ) : null}
-    </div>
+      <NeedsAttention api={api} pollIntervalMs={pollIntervalMs} onSentImmediately={setJustSent} />
+      <ScheduledSends api={api} pollIntervalMs={pollIntervalMs} />
+    </>
+  );
+  if (!results.length) {
+    return (
+      <>
+        <Note>No updates are waiting for approval.</Note>
+        {extras}
+      </>
+    );
+  }
+  return (
+    <>
+      <div className="space-y-1">
+        <h3 className="text-sm font-medium">Waiting for approval</h3>
+        <ul className="divide-y">
+          {results.map((d) => (
+            <DraftItem key={d.id} api={api} draft={d} onSentImmediately={setJustSent} />
+          ))}
+        </ul>
+        {count > pageSize ? (
+          <div className="flex items-center gap-2 text-sm">
+            <Button type="button" size="sm" variant="outline" disabled={!drafts.data.previous} onClick={() => setPage(page - 1)}>
+              Previous
+            </Button>
+            <Button type="button" size="sm" variant="outline" disabled={!drafts.data.next} onClick={() => setPage(page + 1)}>
+              Next
+            </Button>
+          </div>
+        ) : null}
+      </div>
+      {extras}
+    </>
   );
 }

package/src/comms/components/SchedulePicker.tsx

@@ -0,0 +1,53 @@
+/**
+ * Pick when an approved draft goes out: a local date and time plus the time
+ * zone it is meant in (default: the viewer's). The server stores the instant in
+ * UTC; this form only collects the wall-clock time and the zone name.
+ */
+import { useState, type ReactElement } from 'react';
+import { Button, Input, Label } from '@startsimpli/ui';
+
+import type { ScheduleInput } from '../types/index';
+import { NativeSelect, localTimeZone, timeZoneOptions, useFieldId } from './_shared';
+
+export interface SchedulePickerProps {
+  submitLabel: string;
+  pending?: boolean;
+  onSubmit: (schedule: ScheduleInput) => void;
+  onCancel: () => void;
+}
+
+export function SchedulePicker({ submitLabel, pending, onSubmit, onCancel }: SchedulePickerProps): ReactElement {
+  const [when, setWhen] = useState('');
+  const [zone, setZone] = useState(localTimeZone);
+  const whenId = useFieldId('comms-send-at');
+  const zoneId = useFieldId('comms-send-zone');
+  return (
+    <form
+      className="mt-2 flex flex-wrap items-end gap-3 rounded-md border p-3"
+      onSubmit={(e) => {
+        e.preventDefault();
+        if (when) onSubmit({ send_at: when, timezone: zone });
+      }}
+    >
+      <div className="space-y-1">
+        <Label htmlFor={whenId}>Send at</Label>
+        <Input id={whenId} type="datetime-local" required value={when} onChange={(e) => setWhen(e.target.value)} />
+      </div>
+      <div className="space-y-1">
+        <Label htmlFor={zoneId}>Time zone</Label>
+        <div>
+          <NativeSelect id={zoneId} value={zone} onChange={(e) => setZone(e.target.value)}>
+            {timeZoneOptions().map((z) => (
+              <option key={z} value={z}>{z}</option>
+            ))}
+          </NativeSelect>
+        </div>
+      </div>
+      <p className="basis-full text-xs text-muted-foreground">
+        A time that has already passed sends immediately.
+      </p>
+      <Button type="submit" size="sm" disabled={pending || !when}>{submitLabel}</Button>
+      <Button type="button" size="sm" variant="ghost" onClick={onCancel}>Close</Button>
+    </form>
+  );
+}

package/src/comms/components/ScheduledSends.tsx

@@ -0,0 +1,103 @@
+/**
+ * Approved drafts waiting for their send time: when they go out, and the three
+ * things you can still do before then (reschedule, send now, cancel). Once the
+ * send starts the server refuses cancel and reschedule (409), shown as-is.
+ */
+import { useState, type ReactElement } from 'react';
+import { Button } from '@startsimpli/ui';
+
+import type { CommsApi } from '../api/comms';
+import {
+  DEFAULT_POLL_MS,
+  useApproveDraft,
+  useCancelDraft,
+  useDraftAudience,
+  useDrafts,
+  useRescheduleDraft,
+} from '../hooks/index';
+import type { Draft } from '../types/index';
+import { SchedulePicker } from './SchedulePicker';
+import { ErrorNotice, formatDateTime } from './_shared';
+
+export interface ScheduledSendsProps {
+  api: CommsApi;
+  pollIntervalMs?: number;
+  /** Drafts per server page. Default 10. */
+  pageSize?: number;
+}
+
+function ScheduledItem({ api, draft }: { api: CommsApi; draft: Draft }) {
+  const [moving, setMoving] = useState(false);
+  const reschedule = useRescheduleDraft(api);
+  const cancel = useCancelDraft(api);
+  const sendNow = useApproveDraft(api);
+  const zone = draft.send_timezone || undefined;
+  const live = useDraftAudience(api, draft.id, true).data?.preview.count;
+  const frozen = draft.recipient_count;
+  const count =
+    live === undefined
+      ? null
+      : frozen != null && frozen !== live
+        ? `${frozen} recipients when scheduled, ${live} now`
+        : `${live} recipients`;
+  return (
+    <li className="py-3">
+      <div className="flex flex-wrap items-center gap-x-4 gap-y-2">
+        <span className="min-w-[10rem] flex-1 font-medium">{draft.subject || '(no subject)'}</span>
+        <span className="text-sm text-muted-foreground">
+          {`Sends ${formatDateTime(draft.send_at, zone)}`}
+          {zone && zone !== 'UTC' ? ` (${formatDateTime(draft.send_at, 'UTC')})` : ''}
+        </span>
+        <div className="flex flex-wrap gap-2">
+          <Button type="button" size="sm" variant="outline" onClick={() => setMoving((v) => !v)}>Reschedule</Button>
+          <Button type="button" size="sm" variant="outline" disabled={sendNow.isPending} onClick={() => sendNow.mutate(draft.id)}>
+            Send now
+          </Button>
+          <Button type="button" size="sm" variant="ghost" disabled={cancel.isPending} onClick={() => cancel.mutate(draft.id)}>
+            Cancel schedule
+          </Button>
+        </div>
+      </div>
+      {count ? <p className="text-sm text-muted-foreground">{count}</p> : null}
+      {draft.dispatch_error ? (
+        <p className="text-sm text-muted-foreground">{`Trying again: ${draft.dispatch_error}`}</p>
+      ) : null}
+      {moving ? (
+        <SchedulePicker
+          submitLabel="Move send"
+          pending={reschedule.isPending}
+          onCancel={() => setMoving(false)}
+          onSubmit={(s) => reschedule.mutate({ id: draft.id, ...s }, { onSuccess: () => setMoving(false) })}
+        />
+      ) : null}
+      <ErrorNotice error={reschedule.error ?? cancel.error ?? sendNow.error} />
+    </li>
+  );
+}
+
+export function ScheduledSends({ api, pollIntervalMs = DEFAULT_POLL_MS, pageSize = 10 }: ScheduledSendsProps): ReactElement | null {
+  const [page, setPage] = useState(1);
+  const drafts = useDrafts(api, { status: 'scheduled', page, page_size: pageSize }, pollIntervalMs);
+  if (drafts.error) return <ErrorNotice error={drafts.error} />;
+  if (!drafts.data?.results.length) return null;
+  return (
+    <div className="space-y-1">
+      <h3 className="text-sm font-medium">Scheduled to send</h3>
+      <ul className="divide-y">
+        {drafts.data.results.map((d) => (
+          <ScheduledItem key={d.id} api={api} draft={d} />
+        ))}
+      </ul>
+      {drafts.data.count > pageSize ? (
+        <div className="flex items-center gap-2 text-sm">
+          <Button type="button" size="sm" variant="outline" disabled={!drafts.data.previous} onClick={() => setPage(page - 1)}>
+            Previous
+          </Button>
+          <Button type="button" size="sm" variant="outline" disabled={!drafts.data.next} onClick={() => setPage(page + 1)}>
+            Next
+          </Button>
+        </div>
+      ) : null}
+    </div>
+  );
+}

package/src/comms/components/SendLog.tsx

@@ -18,7 +18,7 @@ import {
 import type { CommsApi } from '../api/comms';
 import { useSends } from '../hooks/index';
 import { COMEBACK_PROGRAM_KEY, PRODUCT_UPDATE_PROGRAM_KEY } from '../types/index';
-import { ErrorNotice, NativeSelect, formatDate, useFieldId } from './_shared';
+import { ErrorNotice, NativeSelect, formatDate, formatDateTime, useFieldId } from './_shared';
 
 export interface SendLogProps {
   api: CommsApi;
@@ -73,6 +73,41 @@ export function SendLog({ api, pageSize = 25 }: SendLogProps): ReactElement {
         </div>
       </div>
       <ErrorNotice error={sends.error} />
+      {data?.scheduled?.length ? (
+        <div className="space-y-1">
+          <h3 className="text-sm font-medium">Scheduled and cancelled</h3>
+          <Table>
+            <TableHeader>
+              <TableRow>
+                <TableHead>Subject</TableHead>
+                <TableHead>Program</TableHead>
+                <TableHead>Status</TableHead>
+                <TableHead>Goes out</TableHead>
+                <TableHead>Reason</TableHead>
+              </TableRow>
+            </TableHeader>
+            <TableBody>
+              {data.scheduled.map((s) => (
+                <TableRow key={s.id}>
+                  <TableCell>{s.subject}</TableCell>
+                  <TableCell>{programLabel(s.program_key)}</TableCell>
+                  <TableCell>{s.status}</TableCell>
+                  <TableCell>
+                    {s.status === 'scheduled'
+                      ? formatDateTime(s.send_at, s.send_timezone)
+                      : s.status === 'cancelled'
+                        ? `Cancelled ${formatDateTime(s.cancelled_at)}`
+                        : s.send_at
+                          ? `Was ${formatDateTime(s.send_at, s.send_timezone)}`
+                          : ''}
+                  </TableCell>
+                  <TableCell>{s.reason}</TableCell>
+                </TableRow>
+              ))}
+            </TableBody>
+          </Table>
+        </div>
+      ) : null}
       <Table>
         <TableHeader>
           <TableRow>

package/src/comms/components/_shared.tsx

@@ -41,6 +41,41 @@ export function formatDate(iso: string | null | undefined): string {
   return d.toLocaleDateString(undefined, { day: 'numeric', month: 'short', year: 'numeric' });
 }
 
+/** "Nov 3, 2026, 10:00 AM EST" in `timeZone` (IANA), or the viewer's zone when absent or unknown. */
+export function formatDateTime(iso: string | null | undefined, timeZone?: string | null): string {
+  if (!iso) return '';
+  const d = new Date(iso);
+  if (Number.isNaN(d.getTime())) return '';
+  const opts: Intl.DateTimeFormatOptions = {
+    year: 'numeric', month: 'short', day: 'numeric', hour: 'numeric', minute: '2-digit', timeZoneName: 'short',
+  };
+  try {
+    return d.toLocaleString(undefined, timeZone ? { ...opts, timeZone } : opts);
+  } catch {
+    return d.toLocaleString(undefined, opts);
+  }
+}
+
+/** The viewer's IANA zone, or 'UTC' when the runtime cannot say. */
+export function localTimeZone(): string {
+  try {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC';
+  } catch {
+    return 'UTC';
+  }
+}
+
+/** IANA zones for a picker: the runtime's list when it has one, always with the viewer's zone and UTC. */
+export function timeZoneOptions(): string[] {
+  let zones: string[] = [];
+  try {
+    zones = (Intl as unknown as { supportedValuesOf?: (k: string) => string[] }).supportedValuesOf?.('timeZone') ?? [];
+  } catch {
+    zones = [];
+  }
+  return Array.from(new Set([localTimeZone(), 'UTC', ...zones]));
+}
+
 /** A readable reason code: "not_allowlisted" -> "not allowlisted". */
 export function humanize(code: string): string {
   return code.replace(/_/g, ' ');

package/src/comms/components/index.ts

@@ -7,6 +7,8 @@ export * from './VoiceSettings';
 export * from './SendingDomain';
 export * from './ProductUpdates';
 export * from './DraftReview';
+export * from './SchedulePicker';
+export * from './ScheduledSends';
 export * from './ResultsPanel';
 export * from './SendLog';
 export * from './AudiencePanel';

package/src/comms/hooks/index.ts

@@ -38,7 +38,8 @@ import type {
   ProgramUpdateResult,
   RenderedEmail,
   SendNowResult,
-  SendRow,
+  ScheduleInput,
+  SendsPage,
   SendsQuery,
   StepGeneration,
   TestSendInput,
@@ -274,8 +275,39 @@ export function useUpdateDraft(api: CommsApi): UseMutationResult<Draft, Error, {
   });
 }
 
-export function useApproveDraft(api: CommsApi): UseMutationResult<Draft, Error, string> {
-  return useDraftsWrite(api, (id: string) => api.approveDraft(id));
+/** A draft id to send now, or {id, ...schedule} to schedule it. */
+export type ApproveDraftVars = string | ({ id: string } & Partial<ScheduleInput>);
+
+export function useApproveDraft(api: CommsApi): UseMutationResult<Draft, Error, ApproveDraftVars> {
+  return useScheduleWrite(api, (v: ApproveDraftVars) => {
+    if (typeof v === 'string') return api.approveDraft(v);
+    const { id, send_at, timezone } = v;
+    return api.approveDraft(id, send_at ? { send_at, timezone } : undefined);
+  });
+}
+
+/** Drafts and the sends report both change when a schedule does. */
+function useScheduleWrite<R, V>(api: CommsApi, fn: (v: V) => Promise<R>) {
+  const qc = useQueryClient();
+  return useMutation<R, Error, V>({
+    mutationFn: fn,
+    onSuccess: () => Promise.all([
+      qc.invalidateQueries({ queryKey: commsKeys.draftsAll(api.slug) }),
+      qc.invalidateQueries({ queryKey: ['startsimpli', 'comms', api.slug, 'sends'] }),
+    ]),
+  });
+}
+
+export function useRescheduleDraft(api: CommsApi): UseMutationResult<Draft, Error, { id: string } & ScheduleInput> {
+  return useScheduleWrite(api, ({ id, ...schedule }: { id: string } & ScheduleInput) => api.rescheduleDraft(id, schedule));
+}
+
+export function useRetryDraft(api: CommsApi): UseMutationResult<Draft, Error, string> {
+  return useScheduleWrite(api, (id: string) => api.retryDraft(id));
+}
+
+export function useCancelDraft(api: CommsApi): UseMutationResult<Draft, Error, string> {
+  return useScheduleWrite(api, (id: string) => api.cancelDraft(id));
 }
 
 export function useDiscardDraft(api: CommsApi): UseMutationResult<Draft, Error, string> {
@@ -312,7 +344,7 @@ export function useDeleteAsset(api: CommsApi): UseMutationResult<void, Error, st
 // results ------------------------------------------------------------------
 
 /** Server-side pagination: page/page_size go to the server, never sliced here. */
-export function useSends(api: CommsApi, q: SendsQuery): UseQueryResult<Paginated<SendRow>> {
+export function useSends(api: CommsApi, q: SendsQuery): UseQueryResult<SendsPage> {
   return useQuery({
     queryKey: commsKeys.sends(api.slug, q),
     queryFn: () => api.listSends(q),

package/src/comms/types/index.ts

@@ -194,7 +194,32 @@ export interface ChangesResponse {
   unclassified: string[];
 }
 
-export type DraftApproval = 'pending' | 'approved' | 'discarded';
+export type DraftApproval = 'pending' | 'scheduled' | 'expired' | 'failed' | 'approved' | 'discarded';
+
+/** The named state of a draft/send (server `state`); every one has a reason and a next action. */
+export type DraftState =
+  | 'generating' | 'writing_failed' | 'pending' | 'cancelled' | 'scheduled'
+  | 'expired' | 'failed' | 'sending' | 'sent' | 'discarded';
+
+export type DraftAction =
+  | 'approve' | 'schedule' | 'edit' | 'discard' | 'reschedule' | 'send_now' | 'cancel' | 'retry' | 'wait';
+
+/** Why a pending or expired draft needs a person (no recipients, paused at the scheduled time...). */
+export interface DraftNotice {
+  code: string;
+  reason: string;
+  /** The original send time, on an expired draft. */
+  send_at?: string | null;
+  at?: string;
+}
+
+/** Why a draft failed, and where: dispatch (before any recipient was queued), queue, or send. */
+export interface DraftFailure {
+  stage: 'dispatch' | 'queue' | 'send' | string;
+  code: string;
+  reason: string;
+  at?: string;
+}
 
 export interface Draft {
   id: string;
@@ -216,6 +241,24 @@ export interface Draft {
   audience_is_default?: boolean;
   /** Recipients queued, set at approve. */
   recipient_count?: number | null;
+  /** UTC instant a scheduled draft goes out (approval 'scheduled'; kept after it starts). */
+  send_at?: string | null;
+  /** IANA zone the admin typed send_at in; display only, never changes when it sends. */
+  send_timezone?: string | null;
+  /** Set on a pending draft whose schedule was cancelled. */
+  cancelled_at?: string | null;
+  state?: DraftState;
+  /** What the admin can do next; absent on older servers (treated as the pending set). */
+  next_actions?: DraftAction[];
+  notice?: DraftNotice | null;
+  failure?: DraftFailure | null;
+  /** The requested send_at was already past, so it was sent right away. */
+  sent_immediately?: boolean;
+  requested_send_at?: string | null;
+  completed_at?: string | null;
+  /** A scheduled send whose audience lookup failed and is being retried. */
+  dispatch_attempts?: number;
+  dispatch_error?: string | null;
 }
 
 /** A tenant-evaluated segment: the key (and params) the foundry's backend understands. */
@@ -271,6 +314,16 @@ export interface AudienceSegments {
   segments: AudienceSegment[];
 }
 
+/**
+ * When to send an approved draft. `send_at` is ISO 8601: with an offset or Z it
+ * is an exact instant; a local time ("2026-11-03T10:00") needs `timezone` (IANA).
+ * Stored and dispatched in UTC by the server.
+ */
+export interface ScheduleInput {
+  send_at: string;
+  timezone?: string;
+}
+
 /** POST drafts/: either the email as written (201) or notes to write it from (202, generating). */
 export type DraftCreate =
   | { subject: string; html: string; preheader?: string; text?: string }
@@ -340,6 +393,22 @@ export interface SendRow {
   error: string | null;
 }
 
+/** A draft waiting for its send_at, or one whose schedule was cancelled (sends report). */
+export interface ScheduledSend {
+  id: string;
+  program_key: string;
+  subject: string;
+  status: 'scheduled' | 'expired' | 'failed' | 'cancelled';
+  /** Why: the failure, the pause that expired it, or who cancelled it. */
+  reason?: string;
+  send_at: string | null;
+  send_timezone: string | null;
+  cancelled_at: string | null;
+}
+
+/** GET sends/: the recipient rows (paginated) plus the not-yet-sent drafts. */
+export type SendsPage = Paginated<SendRow> & { scheduled?: ScheduledSend[] };
+
 export interface SendsQuery extends PageParams {
   program?: string;
   status?: string;