@belonguniverseai/react-sdk 0.6.27 → 0.6.29

package/dist/api/goals.d.ts

@@ -107,9 +107,9 @@ export declare const goalViewSchema: z.ZodObject<{
         at: z.ZodString;
     }, z.core.$strip>>>;
     runway: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        long: "long";
         quick: "quick";
         normal: "normal";
-        long: "long";
     }>>>;
 }, z.core.$strip>;
 export type GoalView = z.infer<typeof goalViewSchema>;
@@ -119,10 +119,26 @@ type FetchGoalOutcome = {
 } | {
     readonly status: "none" | "disabled" | "error";
 };
+/**
+ * #766 — one budget an edited goal has still REACHED (`used >= cap`), as
+ * `POST .../goal/edit` reports it (belong-cloud's `GoalBudgetLine`). `reason`
+ * is an OPEN string for the same reason `goalJournalEntrySchema.kind` is: a
+ * budget this dock predates must never turn an edit that applied into an
+ * `error` outcome — the notice falls back to its generic line instead.
+ */
+declare const goalExhaustedBudgetSchema: z.ZodObject<{
+    reason: z.ZodString;
+    used: z.ZodNumber;
+    cap: z.ZodNumber;
+}, z.core.$strip>;
+export type GoalExhaustedBudget = z.infer<typeof goalExhaustedBudgetSchema>;
 export type GoalActionOutcome = {
     readonly status: "ok";
     readonly goalStatus: GoalStatus;
     readonly revived?: boolean;
+    /** Edit only (#766): the budgets that still keep the goal stopped.
+     *  Absent from an older backend, and from every other action. */
+    readonly exhaustedBudgets?: readonly GoalExhaustedBudget[];
 } | {
     readonly status: "conflict";
     readonly goalStatus: GoalStatus;
@@ -167,7 +183,8 @@ export type GoalEditInput = {
  * Content-Type as `{}`). The 202 body carries `revived` — the edit raised a
  * cap past `turns_used`/`tokens_used` and un-stalled a `budget_limited` goal
  * — which `runGoalCommand` (chat.tsx) uses to pick between `goal.edited` and
- * `goal.revived`. Both 409 variants the backend can return
+ * `goal.revived`, and `exhaustedBudgets` (#766), which names what still keeps
+ * a goal that was NOT revived stopped. Both 409 variants the backend can return
  * (`goal_not_editable`: the goal's current state can never be edited;
  * `goal_edit_conflict`: a concurrent edit raced this one) collapse to the
  * same `"conflict"` outcome — the dock has one notice for "try again",

package/dist/api/live-artifacts.d.ts

@@ -0,0 +1,197 @@
+import { QueryClient, UseQueryResult } from '@tanstack/react-query';
+import { Recurrence } from './task-schedules.ts';
+import { ApiClient } from './client.ts';
+/**
+ * The cadence of the schedule a report is bound to, as the SERVER resolves it.
+ *
+ * Structured, never a rendered phrase: the dock formats these parts in the
+ * reader's locale with the same `recurrenceSummaryParams` the Scheduled
+ * surface uses. A server-rendered "daily at 09:00 UTC" would paint English
+ * inside a Spanish dock.
+ *
+ * It arrives from `/v1/live-artifacts` rather than being read client-side
+ * because that list is CALLER-scoped — a report follows its owner across
+ * workspaces — while the dock's own schedule read is workspace-scoped. A
+ * report bound in another workspace, or any report at all in a host with no
+ * workspace selected, could never learn its cadence client-side, and the
+ * overdue warning could never fire for it.
+ */
+export type LiveArtifactCadence = {
+    readonly recurrence: Recurrence;
+    /** Any instant on the cadence, in the schedule's own zone — the wall clock it preserves. */
+    readonly anchorAt: string;
+    readonly timezone: string;
+};
+/** One live report as the list serves it. Instants stay ISO strings (see header). */
+export type LiveArtifactSummary = {
+    readonly liveArtifactId: string;
+    readonly name: string;
+    readonly description: string | null;
+    readonly currentVersion: number;
+    /** The public link's stable id. Present from creation; the public route
+     *  serves it only once the report has actually been shared. */
+    readonly shareSlug: string;
+    readonly shareExpiresAt: string | null;
+    readonly shareRevokedAt: string | null;
+    readonly seriesId: string | null;
+    /** Null when nothing refreshes this report — or when its series is gone. */
+    readonly cadence: LiveArtifactCadence | null;
+    readonly lastRefreshedAt: string | null;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+};
+export type LiveArtifactVersion = {
+    readonly version: number;
+    readonly artifactId: string;
+    /**
+     * The media type of this version's bytes, as the server reads it off the
+     * artifact row. The detail surface needs it to decide whether the CURRENT
+     * version can be framed inline (an interactive HTML app, whose controls only
+     * work with the dock as the frame's parent) or must stay a tab-opened
+     * download (a CSV, a PDF).
+     *
+     * `null` means "this cloud did not say" — see `versionSchema`. A null is
+     * never guessed at: it renders exactly like a non-HTML version, i.e. no
+     * frame.
+     */
+    readonly mimeType: string | null;
+    readonly runId: string | null;
+    readonly summary: string | null;
+    readonly publishedAt: string;
+};
+export type LiveArtifactDetail = LiveArtifactSummary & {
+    readonly versions: readonly LiveArtifactVersion[];
+};
+export type LiveArtifactsListResult = {
+    readonly status: "ready";
+    readonly artifacts: readonly LiveArtifactSummary[];
+    readonly slotsUsed: number;
+    readonly slotLimit: number;
+} | {
+    readonly status: "featureAbsent";
+};
+export type LiveArtifactsAvailability = "available" | "absent";
+/**
+ * Where a report's public link stands right now. Mirrors the server's own
+ * `resolveShareState`, deliberately: the list serves the two timestamps and
+ * the dock has to decide what to say about them, and a second rule here would
+ * be a second truth.
+ */
+export type ShareState = {
+    readonly kind: "never_shared";
+} | {
+    readonly kind: "revoked";
+} | {
+    readonly kind: "expired";
+} | {
+    readonly kind: "live";
+    readonly expiresAt: string;
+};
+export declare const resolveShareState: (row: {
+    readonly shareExpiresAt: string | null;
+    readonly shareRevokedAt: string | null;
+}, now: Date) => ShareState;
+/**
+ * Does sharing from THIS state mint a new url and kill the old one? Only a
+ * re-share after a revoke rotates (design doc D5); a first share has no
+ * previous url to break, and extending a live or expired share keeps it.
+ */
+export declare const shareRotates: (state: ShareState) => boolean;
+/**
+ * The public url for a report's slug. Composed here rather than read back
+ * from the share response, so COPYING a link the user already has never has
+ * to POST (which would silently push the expiry out). Mirrors the server's
+ * `buildLiveShareUrl`.
+ *
+ * ASSUMPTION, stated because it is load-bearing and unenforced: the dock's
+ * configured `apiBaseUrl` is the SAME public origin the server composes from
+ * the request `Host` (`requestOrigin`, live-artifact.routes.ts). The two
+ * derive the origin independently — the server from the host the browser
+ * actually reached, the dock from its own config — so if a deployment ever
+ * points the dock at a base url that is not the public host (an internal Cloud
+ * Run url, a regional alias, a reverse proxy under a different name), the
+ * COPIED link is wrong while the MINTED one stays right, and only the copied
+ * one is silent about it. Keep this in step with `requestOrigin`.
+ */
+export declare const liveShareUrl: (apiBaseUrl: string, slug: string) => string;
+export type ShareLiveArtifactOutcome = {
+    readonly status: "shared";
+    readonly shareUrl: string;
+    readonly expiresAt: string;
+    /**
+     * Did this call MINT A NEW url and kill the previous one? Read off the
+     * server's answer, never guessed from the state the dock happened to be
+     * looking at — the row can be stale, and "the link you already sent
+     * someone is dead now" is not a sentence to say on a guess.
+     */
+    readonly rotated: boolean;
+} | {
+    readonly status: "not_found";
+} | {
+    readonly status: "forbidden";
+} | {
+    readonly status: "error";
+};
+export type RevokeShareOutcome = {
+    readonly status: "revoked";
+} | {
+    readonly status: "not_found";
+} | {
+    readonly status: "forbidden";
+} | {
+    readonly status: "error";
+};
+export type DeleteLiveArtifactOutcome = {
+    readonly status: "deleted";
+} | {
+    readonly status: "not_found";
+} | {
+    readonly status: "forbidden";
+} | {
+    readonly status: "error";
+};
+export type UpdateLiveArtifactOutcome = {
+    readonly status: "updated";
+} | {
+    readonly status: "not_found";
+} | {
+    readonly status: "forbidden";
+} | {
+    readonly status: "name_taken";
+} | {
+    readonly status: "series_not_found";
+} | {
+    readonly status: "error";
+};
+export type UpdateLiveArtifactInput = {
+    readonly liveArtifactId: string;
+    readonly name?: string;
+    readonly description?: string;
+    /** `null` unbinds the schedule; omit the field to leave the binding alone. */
+    readonly seriesId?: string | null;
+};
+export declare const listLiveArtifactsRequest: (api: ApiClient, signal?: AbortSignal) => Promise<LiveArtifactsListResult>;
+export declare const useLiveArtifacts: () => UseQueryResult<LiveArtifactsListResult>;
+/**
+ * Does this deployment have live reports? FALSE until some list call has
+ * RESOLVED `featureAbsent` — while loading, or during an outage, the rail keeps
+ * its entry (a late pop-in reads as a glitch; an outage must not look like a
+ * feature that was never there).
+ */
+export declare const useLiveArtifactsFeatureAbsent: () => boolean;
+export type LiveArtifactDetailResult = {
+    readonly status: "ready";
+    readonly artifact: LiveArtifactDetail;
+} | {
+    readonly status: "not_found";
+};
+export declare const useLiveArtifact: (liveArtifactId: string | null) => UseQueryResult<LiveArtifactDetailResult>;
+/** Both the list and every detail read — a mutation makes both stale. */
+export declare const invalidateLiveArtifacts: (queryClient: QueryClient) => Promise<void>;
+export declare const useShareLiveArtifact: () => import('@tanstack/react-query').UseMutationResult<ShareLiveArtifactOutcome, Error, {
+    readonly liveArtifactId: string;
+    readonly ttlSeconds?: number;
+}, unknown>;
+export declare const useRevokeLiveArtifactShare: () => import('@tanstack/react-query').UseMutationResult<RevokeShareOutcome, Error, string, unknown>;
+export declare const useDeleteLiveArtifact: () => import('@tanstack/react-query').UseMutationResult<DeleteLiveArtifactOutcome, Error, string, unknown>;
+export declare const useUpdateLiveArtifact: () => import('@tanstack/react-query').UseMutationResult<UpdateLiveArtifactOutcome, Error, UpdateLiveArtifactInput, unknown>;

package/dist/api/my-usage.d.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+import { ApiClient } from './client.ts';
+export declare const myUsageSchema: z.ZodObject<{
+    timeZone: z.ZodLiteral<"UTC">;
+    asOf: z.ZodISODateTime;
+    days: z.ZodArray<z.ZodObject<{
+        date: z.ZodISODate;
+        weightedTokens: z.ZodNumber;
+    }, z.core.$strip>>;
+    today: z.ZodObject<{
+        date: z.ZodISODate;
+        weightedTokens: z.ZodNumber;
+    }, z.core.$strip>;
+    monthToDate: z.ZodObject<{
+        from: z.ZodISODate;
+        weightedTokens: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type MyUsage = z.infer<typeof myUsageSchema>;
+export type MyUsageState = {
+    readonly status: "ready";
+    readonly usage: MyUsage;
+} | {
+    readonly status: "unavailable";
+};
+export declare const fetchMyUsage: (client: ApiClient) => Promise<MyUsageState>;
+/** Keyed by the account speaking to the API (`useAccountKey`), so it is purged on a switch. */
+export declare const useMyUsage: (accountKey: string) => import('@tanstack/react-query').UseQueryResult<NoInfer<MyUsageState>, Error>;

package/dist/api/queries.d.ts

@@ -6,17 +6,17 @@
  */
 export declare const useSessions: (limit?: number) => import('@tanstack/react-query').UseQueryResult<NoInfer<{
     sessions: readonly {
-        readonly sessionId: import('node_modules/@belong/cloud/src/platform/ids.ts').SessionId;
+        readonly sessionId: import('../../../../apps/belong-cloud/src/platform/ids.ts').SessionId;
         readonly title: string | null;
-        readonly status: import('node_modules/@belong/cloud/src/features/sessions/session.repo.ts').SessionRow["status"];
+        readonly status: import('../../../../apps/belong-cloud/src/features/sessions/session.repo.ts').SessionRow["status"];
         readonly updatedAt: string;
     }[];
 }>, Error>;
 export declare const useSession: (sessionId: string | null) => import('@tanstack/react-query').UseQueryResult<NoInfer<{
-    readonly sessionId: import('node_modules/@belong/cloud/src/platform/ids.ts').SessionId;
+    readonly sessionId: import('../../../../apps/belong-cloud/src/platform/ids.ts').SessionId;
     readonly workspaceExternalId: string | null;
     readonly title: string | null;
-    readonly status: import('node_modules/@belong/cloud/src/features/sessions/session.repo.ts').SessionRow["status"];
+    readonly status: import('../../../../apps/belong-cloud/src/features/sessions/session.repo.ts').SessionRow["status"];
     readonly createdAt: string;
     readonly updatedAt: string;
 }>, Error>;
@@ -24,6 +24,7 @@ export declare const useSessionStats: (sessionId: string | null) => import('@tan
     readonly totalInputTokens: number;
     readonly totalOutputTokens: number;
     readonly totalTokens: number;
+    readonly totalWeightedTokens: number;
     readonly totalCacheReadInputTokens: number;
     readonly totalCacheWriteInputTokens: number;
     readonly turns: number;
@@ -36,5 +37,6 @@ export declare const useSessionStats: (sessionId: string | null) => import('@tan
         readonly inputTokens: number;
         readonly outputTokens: number;
         readonly totalTokens: number;
+        readonly weightedTokens: number;
     }[];
 }>, Error>;

package/dist/api/query-keys.d.ts

@@ -47,9 +47,24 @@ export declare const queryKeys: {
     /** Invalidation prefix for every task-schedule read (list + detail + runs). */
     taskSchedules: readonly ["belong", "task-schedules"];
     apiKeys: (ownerCacheKey: string) => readonly ["belong", "api-keys", string];
-    taskScheduleList: (workspaceKey: string, filter: string, q: string) => readonly ["belong", "task-schedules", "list", string, string, string];
-    taskSchedule: (workspaceKey: string, taskScheduleId: string) => readonly ["belong", "task-schedules", "detail", string, string];
-    taskScheduleRuns: (workspaceKey: string, taskScheduleId: string) => readonly ["belong", "task-schedules", "detail", string, string, "runs"];
+    /**
+     * Plan 018 — the signed-in user's own usage. ACCOUNT-scoped (`accountKey`
+     * from `api/account-scope.ts`, right after the prefix like the schedule keys),
+     * so a host that swaps accounts in place never paints the previous user's
+     * usage.
+     */
+    myUsage: (accountKey: string) => readonly ["belong", "my-usage", string];
+    /**
+     * Schedule reads are ACCOUNT-scoped as well as workspace-scoped (`accountKey`
+     * from `api/account-scope.ts`). `/v1/task-schedules` keys off the caller, and
+     * the account segment comes FIRST so `api/account-scope.ts` can find it in the
+     * same position for every one of these three — an unpartitioned schedule list
+     * showed account A's schedule titles to account B inside `BindScheduleDialog`
+     * (PR #614 audit finding 3, second pass).
+     */
+    taskScheduleList: (accountKey: string, workspaceKey: string, filter: string, q: string) => readonly ["belong", "task-schedules", "list", string, string, string, string];
+    taskSchedule: (accountKey: string, workspaceKey: string, taskScheduleId: string) => readonly ["belong", "task-schedules", "detail", string, string, string];
+    taskScheduleRuns: (accountKey: string, workspaceKey: string, taskScheduleId: string) => readonly ["belong", "task-schedules", "detail", string, string, string, "runs"];
     /** Invalidation prefix for every saved-prompt read (BEL-256). */
     prePrompts: readonly ["belong", "pre-prompts"];
     /** Workspace-scoped saved-prompt list (same "" unscoped convention). */
@@ -67,6 +82,32 @@ export declare const queryKeys: {
      * every host workspace switch (R61).
      */
     skillLibraryAvailability: readonly ["belong", "skill-library", "availability"];
+    /** Invalidation prefix for every live-artifact read (live-artifacts design doc §11.2). */
+    liveArtifacts: readonly ["belong", "live-artifacts"];
+    /**
+     * The owner's live-artifact list, partitioned by ACCOUNT (`accountKey` from
+     * `api/account-scope.ts` — the token's stable tenant+user claims, never the
+     * rotating token itself). `/v1/live-artifacts` is scoped by (tenant, user),
+     * and the SDK lets a host swap its token in place without remounting the
+     * memoized QueryClient: a key that named only the resource let the next
+     * account read the previous one's rows — including the public share slug that
+     * grants anonymous access to them (P1, 2026-09-27 PR #614 deep audit
+     * finding 3).
+     *
+     * NOT workspace-scoped, and deliberately so: a live report follows its owner
+     * across workspaces, so a per-workspace cache would paint the same list under
+     * two keys and let one of them go stale (the `connectors` reasoning, not the
+     * `skillLibrary` one).
+     */
+    liveArtifactList: (accountKey: string) => readonly ["belong", "live-artifacts", "list", string];
+    liveArtifactDetail: (accountKey: string, liveArtifactId: string) => readonly ["belong", "live-artifacts", "detail", string, string];
+    /**
+     * UNSCOPED deployment probe, written by every list resolution and read by the
+     * rail — same reason as `skillLibraryAvailability`: whether the feature
+     * exists is a property of the CELL, so a host workspace switch must never pop
+     * a dead rail entry back in.
+     */
+    liveArtifactsAvailability: readonly ["belong", "live-artifacts", "availability"];
     /**
      * Invalidation prefix for every custom-connector read. NOT workspace-scoped:
      * `/v1/connectors` keys off the CALLER, not a workspace — a user's connected

package/dist/api/task-schedule-sharing.d.ts

@@ -6,6 +6,11 @@ export declare const sharedScheduleSchema: z.ZodObject<{
     explicitTitle: z.ZodNullable<z.ZodString>;
     message: z.ZodString;
     sharedRecipients: z.ZodDefault<z.ZodArray<z.ZodEmail>>;
+    sharedCopies: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        cc: z.ZodOptional<z.ZodArray<z.ZodEmail>>;
+        bcc: z.ZodOptional<z.ZodArray<z.ZodEmail>>;
+        replyTo: z.ZodOptional<z.ZodArray<z.ZodEmail>>;
+    }, z.core.$strip>>>;
     role: z.ZodEnum<{
         edit: "edit";
         owner: "owner";
@@ -19,11 +24,11 @@ export declare const sharedScheduleSchema: z.ZodObject<{
     recurrence: z.ZodPipe<z.ZodObject<{
         kind: z.ZodEnum<{
             none: "none";
-            manual: "manual";
             daily: "daily";
             weekdays: "weekdays";
             weekly: "weekly";
             interval: "interval";
+            manual: "manual";
         }>;
         intervalMinutes: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>, z.ZodTransform<{
@@ -40,7 +45,7 @@ export declare const sharedScheduleSchema: z.ZodObject<{
         readonly kind: "interval";
         readonly intervalMinutes: number;
     }, {
-        kind: "none" | "manual" | "daily" | "weekdays" | "weekly" | "interval";
+        kind: "none" | "daily" | "weekdays" | "weekly" | "interval" | "manual";
         intervalMinutes?: number | undefined;
     }>>;
     anchorAt: z.ZodISODateTime;
@@ -54,6 +59,11 @@ export declare const useSharedSchedules: () => import('@tanstack/react-query').U
     explicitTitle: string | null;
     message: string;
     sharedRecipients: string[];
+    sharedCopies: {
+        cc?: string[] | undefined;
+        bcc?: string[] | undefined;
+        replyTo?: string[] | undefined;
+    } | null;
     role: "edit" | "owner" | "use";
     owner: string;
     ownerTenant: string;
@@ -88,6 +98,11 @@ export declare const useSharedSchedule: (definitionId: string | null) => import(
     explicitTitle: string | null;
     message: string;
     sharedRecipients: string[];
+    sharedCopies: {
+        cc?: string[] | undefined;
+        bcc?: string[] | undefined;
+        replyTo?: string[] | undefined;
+    } | null;
     role: "edit" | "owner" | "use";
     owner: string;
     ownerTenant: string;
@@ -149,7 +164,7 @@ export declare const useUpdateSharedSchedule: () => import('@tanstack/react-quer
     revision: number;
 }, Error, {
     readonly definitionId: string;
-    readonly patch: Omit<UpdateTaskScheduleSeriesInput["patch"], "mode" | "recipients" | "expectedRevision"> & {
+    readonly patch: Omit<UpdateTaskScheduleSeriesInput["patch"], "mode" | "recipients" | "copies" | "expectedRevision"> & {
         readonly expectedRevision: number;
     };
 }, unknown>;

package/dist/api/task-schedules.d.ts

@@ -19,6 +19,13 @@ export type DeleteTaskScheduleOutcome = {
 } | {
     readonly status: "not_found" | "already_started" | "error";
 };
+/** cc / bcc / replyTo on a schedule's email. Empty or absent lists mean none. */
+export declare const emailCopiesSchema: z.ZodObject<{
+    cc: z.ZodOptional<z.ZodArray<z.ZodEmail>>;
+    bcc: z.ZodOptional<z.ZodArray<z.ZodEmail>>;
+    replyTo: z.ZodOptional<z.ZodArray<z.ZodEmail>>;
+}, z.core.$strip>;
+export type EmailCopies = z.infer<typeof emailCopiesSchema>;
 export type CreateTaskScheduleRequest = {
     readonly scheduledFor: Date;
     readonly timeExpression: string;
@@ -46,15 +53,15 @@ export declare const createTaskSchedule: (apiBaseUrl: string, input: CreateTaskS
 export declare const deleteTaskSchedule: (apiBaseUrl: string, taskScheduleId: string) => Promise<DeleteTaskScheduleOutcome>;
 export declare const recurrenceKindSchema: z.ZodEnum<{
     none: "none";
-    manual: "manual";
     daily: "daily";
     weekdays: "weekdays";
     weekly: "weekly";
     interval: "interval";
+    manual: "manual";
 }>;
 export type RecurrenceKind = z.infer<typeof recurrenceKindSchema>;
-/** Bounds for the `interval` cadence (BEL-157): 1 minute up to a full day. */
-export declare const MIN_RECURRENCE_INTERVAL_MINUTES = 1;
+/** Bounds for the `interval` cadence (BEL-157): 5 minutes up to a full day. */
+export declare const MIN_RECURRENCE_INTERVAL_MINUTES = 5;
 export declare const MAX_RECURRENCE_INTERVAL_MINUTES = 1440;
 /**
  * Recurrence as a discriminated union: only `interval` carries a width. Used
@@ -87,11 +94,11 @@ export type Recurrence = {
 export declare const recurrenceSchema: z.ZodPipe<z.ZodObject<{
     kind: z.ZodEnum<{
         none: "none";
-        manual: "manual";
         daily: "daily";
         weekdays: "weekdays";
         weekly: "weekly";
         interval: "interval";
+        manual: "manual";
     }>;
     intervalMinutes: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>, z.ZodTransform<{
@@ -108,7 +115,7 @@ export declare const recurrenceSchema: z.ZodPipe<z.ZodObject<{
     readonly kind: "interval";
     readonly intervalMinutes: number;
 }, {
-    kind: "none" | "manual" | "daily" | "weekdays" | "weekly" | "interval";
+    kind: "none" | "daily" | "weekdays" | "weekly" | "interval" | "manual";
     intervalMinutes?: number | undefined;
 }>>;
 export declare const taskScheduleSeriesStatusSchema: z.ZodEnum<{
@@ -132,11 +139,11 @@ declare const taskScheduleListItemSchema: z.ZodObject<{
     recurrence: z.ZodPipe<z.ZodObject<{
         kind: z.ZodEnum<{
             none: "none";
-            manual: "manual";
             daily: "daily";
             weekdays: "weekdays";
             weekly: "weekly";
             interval: "interval";
+            manual: "manual";
         }>;
         intervalMinutes: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>, z.ZodTransform<{
@@ -153,7 +160,7 @@ declare const taskScheduleListItemSchema: z.ZodObject<{
         readonly kind: "interval";
         readonly intervalMinutes: number;
     }, {
-        kind: "none" | "manual" | "daily" | "weekdays" | "weekly" | "interval";
+        kind: "none" | "daily" | "weekdays" | "weekly" | "interval" | "manual";
         intervalMinutes?: number | undefined;
     }>>;
     timezone: z.ZodString;
@@ -183,11 +190,11 @@ export declare const taskScheduleDetailSchema: z.ZodObject<{
     recurrence: z.ZodPipe<z.ZodObject<{
         kind: z.ZodEnum<{
             none: "none";
-            manual: "manual";
             daily: "daily";
             weekdays: "weekdays";
             weekly: "weekly";
             interval: "interval";
+            manual: "manual";
         }>;
         intervalMinutes: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>, z.ZodTransform<{
@@ -204,7 +211,7 @@ export declare const taskScheduleDetailSchema: z.ZodObject<{
         readonly kind: "interval";
         readonly intervalMinutes: number;
     }, {
-        kind: "none" | "manual" | "daily" | "weekdays" | "weekly" | "interval";
+        kind: "none" | "daily" | "weekdays" | "weekly" | "interval" | "manual";
         intervalMinutes?: number | undefined;
     }>>;
     timezone: z.ZodString;
@@ -230,6 +237,11 @@ export declare const taskScheduleDetailSchema: z.ZodObject<{
         revision: z.ZodNumber;
         workspaceCount: z.ZodNumber;
         sharedRecipients: z.ZodOptional<z.ZodArray<z.ZodEmail>>;
+        sharedCopies: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            cc: z.ZodOptional<z.ZodArray<z.ZodEmail>>;
+            bcc: z.ZodOptional<z.ZodArray<z.ZodEmail>>;
+            replyTo: z.ZodOptional<z.ZodArray<z.ZodEmail>>;
+        }, z.core.$strip>>>;
     }, z.core.$strip>>>;
     explicitTitle: z.ZodDefault<z.ZodNullable<z.ZodString>>;
     message: z.ZodString;
@@ -246,10 +258,20 @@ export declare const taskScheduleDetailSchema: z.ZodObject<{
     notification: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
         kind: z.ZodLiteral<"completion_email">;
         recipients: z.ZodOptional<z.ZodArray<z.ZodEmail>>;
+        copies: z.ZodOptional<z.ZodObject<{
+            cc: z.ZodOptional<z.ZodArray<z.ZodEmail>>;
+            bcc: z.ZodOptional<z.ZodArray<z.ZodEmail>>;
+            replyTo: z.ZodOptional<z.ZodArray<z.ZodEmail>>;
+        }, z.core.$strip>>;
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<"custom_email">;
         templatePath: z.ZodString;
         recipients: z.ZodOptional<z.ZodArray<z.ZodEmail>>;
+        copies: z.ZodOptional<z.ZodObject<{
+            cc: z.ZodOptional<z.ZodArray<z.ZodEmail>>;
+            bcc: z.ZodOptional<z.ZodArray<z.ZodEmail>>;
+            replyTo: z.ZodOptional<z.ZodArray<z.ZodEmail>>;
+        }, z.core.$strip>>;
     }, z.core.$strip>], "kind">>;
     microsoftTeamsDelivery: z.ZodDefault<z.ZodNullable<z.ZodObject<{
         destination: z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -274,9 +296,13 @@ export type TaskScheduleDetail = z.infer<typeof taskScheduleDetailSchema>;
 declare const taskScheduleRunSchema: z.ZodObject<{
     taskScheduleRunId: z.ZodUUID;
     occurrenceKind: z.ZodEnum<{
-        scheduled: "scheduled";
         manual: "manual";
+        scheduled: "scheduled";
     }>;
+    seriesStatusAtRequest: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
+        active: "active";
+        paused: "paused";
+    }>>>;
     displayStatus: z.ZodEnum<{
         failed: "failed";
         running: "running";
@@ -356,10 +382,20 @@ export declare const useTaskSchedule: (taskScheduleId: string | null) => import(
     notification: {
         kind: "completion_email";
         recipients?: string[] | undefined;
+        copies?: {
+            cc?: string[] | undefined;
+            bcc?: string[] | undefined;
+            replyTo?: string[] | undefined;
+        } | undefined;
     } | {
         kind: "custom_email";
         templatePath: string;
         recipients?: string[] | undefined;
+        copies?: {
+            cc?: string[] | undefined;
+            bcc?: string[] | undefined;
+            replyTo?: string[] | undefined;
+        } | undefined;
     };
     microsoftTeamsDelivery: {
         destination: {
@@ -382,11 +418,23 @@ export declare const useTaskSchedule: (taskScheduleId: string | null) => import(
         revision: number;
         workspaceCount: number;
         sharedRecipients?: string[] | undefined;
+        sharedCopies?: {
+            cc?: string[] | undefined;
+            bcc?: string[] | undefined;
+            replyTo?: string[] | undefined;
+        } | null | undefined;
     } | null | undefined;
 }>, Error>;
+/**
+ * #837: read a schedule's status from the cloud NOW (not the cache), writing
+ * it into the cached detail so every surface shows it. Run-now uses it after
+ * a `task_schedule_series_status_changed` 409 to decide what to ask next.
+ */
+export declare const useRefetchTaskScheduleStatus: () => (taskScheduleId: string) => Promise<TaskScheduleDetail["status"]>;
 export declare const useTaskScheduleRuns: (taskScheduleId: string | null) => import('@tanstack/react-query').UseInfiniteQueryResult<{
     taskScheduleRunId: string;
-    occurrenceKind: "scheduled" | "manual";
+    occurrenceKind: "manual" | "scheduled";
+    seriesStatusAtRequest: "active" | "paused" | null;
     displayStatus: "failed" | "running" | "completed" | "needs_attention";
     scheduledFor: string;
     startedAt: string | null;
@@ -405,12 +453,20 @@ export type CreateTaskScheduleSeriesInput = {
     readonly recurrence: Recurrence;
     readonly clientScheduleId: string;
     readonly workspaceExternalId?: string;
+    readonly notification?: {
+        readonly kind: "completion_email";
+        readonly copies?: EmailCopies;
+    };
 };
 export type UpdateTaskScheduleSeriesInput = {
     readonly taskScheduleId: string;
     readonly patch: {
         readonly expectedRevision?: number;
         readonly sharedRecipients?: string[];
+        /** Replaces this installation's cc/bcc/replyTo; `null` clears them. */
+        readonly copies?: EmailCopies | null;
+        /** Replaces the shared definition's cc/bcc/replyTo (owner or editor). */
+        readonly sharedCopies?: EmailCopies;
         readonly title?: string | null;
         readonly message?: string;
         readonly scheduledFor?: string;
@@ -435,8 +491,16 @@ export declare const useResumeTaskSchedule: () => import('@tanstack/react-query'
     status: "completed" | "active" | "needs_attention";
     nextRunAt: string | null;
 }, Error, string, unknown>;
+/** The two statuses run-now accepts — what the UI showed when it asked (#837). */
+export type RunNowSeriesStatus = "active" | "paused";
+/** The 409 run-now answers when the task's status is no longer the expected one. */
+export declare const RUN_NOW_STATUS_CHANGED = "task_schedule_series_status_changed";
 export declare const useRunNowTaskSchedule: () => import('@tanstack/react-query').UseMutationResult<{
     taskScheduleRunId: string;
-}, Error, string, unknown>;
+}, Error, {
+    readonly taskScheduleId: string;
+    /** The status the surface showed; the cloud refuses (409) if it moved. */
+    readonly expectedSeriesStatus: RunNowSeriesStatus;
+}, unknown>;
 export declare const useDeleteTaskScheduleSeries: () => import('@tanstack/react-query').UseMutationResult<void, Error, string, unknown>;
 export {};