deepline 0.3.88 → 0.3.90

package/dist/index.d.ts

@@ -1,8 +1,130 @@
 /// <reference path="./text-imports.d.ts" />
-import { c as PlayCompilerManifest, i as PlayAuthoringColumnMap, j as PlayAuthoringColumnResolver, k as PlayAuthoringRuntimeContext, l as PlayAuthoringConditionalStepResolver, m as PlayAuthoringCsvInput, n as PlayAuthoringCsvOptions, o as PlayAuthoringDatasetBuilder, p as PlayAuthoringDatasetColumnDefinition, q as PlayAuthoringDatasetColumnRunInput, T as ToolExecuteResult, r as PlayAuthoringReferenceLike, s as PlayReturnObject$1, t as PlayAuthoringDefineConfig, u as PlayAuthoringDefinedPlay, v as PlayAuthoringFetchOptions, w as PlayAuthoringFileInput, x as PlayAuthoringBindings, y as PlayAuthoringCallExecution, z as PlayAuthoringCallOptions, A as PlayAuthoringFetchResponse, B as PlayAuthoringInputContract, C as PlayAuthoringStepProgramStep, D as PlayAuthoringRuntimeStepOptions, E as PlaySqlListenerDeclaration, F as PlaySqlListenerEvent, G as PlaySqlListenerOperation, H as PlaySqlQuery, I as PlayAuthoringStepOptions, J as PlayAuthoringStepProgram, K as PlayAuthoringStepProgramResolver, L as PlayAuthoringStepResolver, M as PlayToolExecutionRequest, N as PlayAuthoringStepProgramOptions, O as DeeplineError, Q as ToolExecutionError, R as ToolExecutionErrorOptions } from './compiler-manifest-Dbov16F7.js';
-export { S as CtxFetchHttpError, U as DEEPLINE_EXTRACTOR_TARGETS, V as DEEPLINE_EXTRACTOR_TARGET_DEFINITIONS, W as DeeplineEmailStatusGetterValue, X as DeeplineExtractorTarget, Y as DeeplineGetterValue, Z as DeeplineGetterValueMap, _ as JOB_CHANGE_STATUS_VALUES, $ as JobChangeStatus, a0 as PHONE_STATUS_VALUES, a1 as PhoneStatus, a2 as PlayDataset, a3 as PlayDatasetInput, a4 as PreviousCell, a5 as ProviderTransientError, a6 as ProviderTransientErrorCategory, a7 as ProviderUnavailableError, a8 as ProviderUnavailableReason, a9 as ToolExecutionErrorCategory, aa as ToolExecutionErrorOrigin, ab as ToolExecutionFailureV1, ac as ToolExecutionNetworkKind, ad as ToolExecutionNetworkScope, ae as ToolExecutionPublicDetails, af as getProviderUnavailableReason, ag as isDeeplineExtractorTarget, ah as isProviderUnavailable, ai as isProviderWaterfallUnavailableError } from './compiler-manifest-Dbov16F7.js';
+import { P as PlayCompilerManifest, A as AsyncPlayRunRef$1, a as PlayAuthoringColumnMap, b as PlayAuthoringColumnResolver, c as PlayAuthoringRuntimeContext, d as PlayAuthoringConditionalStepResolver, e as PlayAuthoringCsvInput, f as PlayAuthoringCsvOptions, g as PlayAuthoringDatasetBuilder, h as PlayAuthoringDatasetColumnDefinition, i as PlayAuthoringDatasetColumnRunInput, T as ToolExecuteResult, j as PlayAuthoringReferenceLike, k as PlayReturnObject$1, l as PlayAuthoringDefineConfig, m as PlayAuthoringDefinedPlay, n as PlayAuthoringFetchOptions, o as PlayAuthoringFileInput, p as PlayAuthoringAsyncCallOptions, q as PlayAuthoringBindings, r as PlayAuthoringCallExecution, s as PlayAuthoringCallOptions, t as PlayAuthoringFetchResponse, u as PlayAuthoringInputContract, v as PlayRunId$1, w as PlayAuthoringStepProgramStep, x as PlayAuthoringRuntimeStepOptions, y as PlaySqlListenerDeclaration, z as PlaySqlListenerEvent, B as PlaySqlListenerOperation, C as PlaySqlQuery, D as PlayAuthoringStepOptions, E as PlayAuthoringStepProgram, F as PlayAuthoringStepProgramResolver, G as PlayAuthoringStepResolver, H as PlayToolExecutionRequest, I as PlayAuthoringStepProgramOptions, J as DeeplineError, K as ToolExecutionError, L as ToolExecutionErrorOptions } from './compiler-manifest-BaJfE-5H.js';
+export { M as CtxFetchHttpError, N as DEEPLINE_EXTRACTOR_TARGETS, O as DEEPLINE_EXTRACTOR_TARGET_DEFINITIONS, Q as DeeplineEmailStatusGetterValue, R as DeeplineExtractorTarget, S as DeeplineGetterValue, U as DeeplineGetterValueMap, V as JOB_CHANGE_STATUS_VALUES, W as JobChangeStatus, X as PHONE_STATUS_VALUES, Y as PhoneStatus, Z as PlayDataset, _ as PlayDatasetInput, $ as PreviousCell, a0 as ProviderTransientError, a1 as ProviderTransientErrorCategory, a2 as ProviderUnavailableError, a3 as ProviderUnavailableReason, a4 as ToolExecutionErrorCategory, a5 as ToolExecutionErrorOrigin, a6 as ToolExecutionFailureV1, a7 as ToolExecutionNetworkKind, a8 as ToolExecutionNetworkScope, a9 as ToolExecutionPublicDetails, aa as getProviderUnavailableReason, ab as isDeeplineExtractorTarget, ac as isProviderUnavailable, ad as isProviderWaterfallUnavailableError } from './compiler-manifest-BaJfE-5H.js';
+import { MonitorFleetDefinition } from './monitor-fleet-contract.js';
+export { AdmittedMonitorFleetAuthoringContract, MONITOR_FLEET_AUTHORING_CONTRACT_CHANGELOG, MONITOR_FLEET_AUTHORING_CONTRACT_EDITION, MONITOR_FLEET_DOCUMENTATION, MONITOR_FLEET_FRONTIER_MAX_ROWS, MONITOR_FLEET_MAX_MEMBERS, MonitorFleetAuthoringContractEdition, MonitorFleetAuthoringContractResult, MonitorFleetColumn, MonitorFleetContractIssue, MonitorFleetExpression, MonitorFleetTemplate, admitMonitorFleetAuthoringContract, defineMonitorFleet, fleetColumn, fleetKey, validateMonitorFleetDefinition } from './monitor-fleet-contract.js';
 import '@sinclair/typebox';
 
+type ProductNotificationFactValue = string | number | boolean;
+type ProductNotificationFacts = Record<string, ProductNotificationFactValue>;
+type ProductNotificationDestinationSettings = {
+    kind: 'slack';
+    targetKind: 'channel' | 'member';
+    targetId: string;
+    targetName: string;
+    oauthConnectionId: string;
+} | {
+    kind: 'email_addresses';
+    to: string[];
+    cc?: string[];
+    bcc?: string[];
+} | {
+    kind: 'email_roles';
+    roles: string[];
+};
+type ProductNotificationTrigger = {
+    kind: 'each_match';
+} | {
+    kind: 'state_transition';
+    targetState: string;
+    reasonCode?: string;
+} | {
+    kind: 'threshold_crossing';
+    direction: 'above' | 'below' | 'at_or_above';
+    threshold: number;
+    unit?: string;
+} | {
+    kind: 'consecutive_outcomes';
+    count: number;
+    outcome: string;
+    maxLookback: number;
+};
+type ProductNotificationDeliveryTiming = {
+    mode: 'immediate';
+} | {
+    mode: 'immediate_first' | 'digest_only' | 'rolling_limit';
+    windowMs: number;
+};
+type ProductNotificationRepeatMode = 'on_enter' | 'every_match';
+type ProductNotificationDefaultPolicy = {
+    version: number;
+    groups: ProductNotificationDefaultGroup[];
+    destinations: ProductNotificationDefaultDestination[];
+    rules: ProductNotificationDefaultRule[];
+};
+type ProductNotificationDefaultGroup = {
+    groupKey: string;
+    name: string;
+    enabled: boolean;
+    /** Omitted only by stored compatibility rows; effective groups are normalized. */
+    deliveryTiming?: ProductNotificationDeliveryTiming;
+};
+type ProductNotificationDefaultDestination = {
+    destinationKey: string;
+    groupKey: string;
+    name: string;
+    enabled: boolean;
+    settings: ProductNotificationDestinationSettings;
+};
+type ProductNotificationDefaultRule = {
+    ruleKey: string;
+    groupKey: string;
+    enabled: boolean;
+    notificationType: string;
+    eventName: string;
+    eventFilter: ProductNotificationFacts;
+    trigger: ProductNotificationTrigger;
+    /** Omitted only by stored compatibility rows; effective rules are normalized. */
+    repeatMode?: ProductNotificationRepeatMode;
+    /** Omitted only by stored compatibility rows; effective rules are normalized. */
+    conditionGeneration?: number;
+};
+type ProductNotificationConfigMode = 'custom' | 'replace_default' | 'disable_default';
+/** The provider-neutral state edited by UI and CLI clients for one group. */
+type ProductNotificationGroupDraft = {
+    group: EffectiveProductNotificationGroup;
+    destinations: EffectiveProductNotificationDestination[];
+    rules: EffectiveProductNotificationRule[];
+};
+/** Public configuration intent. Convex alone derives sparse override writes. */
+type ProductNotificationConfigurationChange = {
+    kind: 'save_group';
+    draft: ProductNotificationGroupDraft;
+} | {
+    kind: 'delete_group';
+    groupKey: string;
+};
+type EffectiveProductNotificationGroup = Omit<ProductNotificationDefaultGroup, 'deliveryTiming'> & {
+    deliveryTiming: ProductNotificationDeliveryTiming;
+    source: 'default' | 'workspace';
+    configMode: 'default' | ProductNotificationConfigMode;
+    defaultKey?: string;
+    version: number;
+};
+type EffectiveProductNotificationDestination = ProductNotificationDefaultDestination & {
+    source: 'default' | 'workspace';
+    configMode: 'default' | ProductNotificationConfigMode;
+    defaultKey?: string;
+    version: number;
+    status: string;
+};
+type EffectiveProductNotificationRule = Omit<ProductNotificationDefaultRule, 'repeatMode' | 'conditionGeneration'> & {
+    repeatMode: ProductNotificationRepeatMode;
+    conditionGeneration: number;
+    source: 'default' | 'workspace';
+    configMode: 'default' | ProductNotificationConfigMode;
+    defaultKey?: string;
+    version: number;
+};
+type EffectiveProductNotificationConfiguration = {
+    /** Exact policy used to materialize this effective configuration. */
+    defaultPolicy: ProductNotificationDefaultPolicy | null;
+    workspaceVersion: number;
+    groups: EffectiveProductNotificationGroup[];
+    destinations: EffectiveProductNotificationDestination[];
+    rules: EffectiveProductNotificationRule[];
+};
+
 declare const FIXTURE_BEHAVIOR_VERSION: 1;
 declare const FIXTURE_BEHAVIOR_RESPONSE_VERSION: 2;
 declare const FIXTURE_BEHAVIOR_REPLAY_VERSION: 3;
@@ -135,7 +257,11 @@ type PlayActivityState = {
     code?: string;
 };
 type PlayActivityObservation = {
-    schemaVersion: 1;
+    /**
+     * Retired marker. Producers stopped writing it; envelopes still in flight
+     * from an older producer carry `1`, so readers tolerate both shapes.
+     */
+    schemaVersion?: 1;
     /** Stable within one run, for example `tool:discover_ctos` or `dataset:leads`. */
     activityId: string;
     /** Optional owning play step. */
@@ -181,6 +307,503 @@ declare function formatPlayBootstrapFinderKinds(): string;
 declare function formatPlayBootstrapTemplates(): string;
 declare function formatPlayBootstrapFinderKindsForSentence(): string;
 
+/** Type-owned content, independent of email markup and persisted audit strings. */
+type NotificationText = string | readonly (string | {
+    strong: string;
+} | {
+    workspace: true;
+})[];
+
+/**
+ * The sections the configuration surface skims by. Declared here so UI, API,
+ * and CLI order and label them identically.
+ */
+declare const PRODUCT_NOTIFICATION_CATEGORIES: readonly [{
+    readonly id: "credits";
+    readonly name: "Credits and usage";
+}, {
+    readonly id: "plays";
+    readonly name: "Play runs";
+}];
+type ProductNotificationCategoryId = (typeof PRODUCT_NOTIFICATION_CATEGORIES)[number]['id'];
+type ProductNotificationTypeCatalogMetadata = {
+    name: string;
+    description: string;
+    category: ProductNotificationCategoryId;
+    allowMultiple: boolean;
+    editor: {
+        kind: 'threshold';
+        label: string;
+        defaultThreshold: number;
+        minimum: number;
+        maximum?: number;
+        suffix?: string;
+        /**
+         * When set, editors show and accept `remainingOf - threshold` (for
+         * example percent remaining) while the stored trigger stays in the
+         * runtime's "used" terms. Bounds and defaults are stored values.
+         */
+        remainingOf?: number;
+    } | {
+        kind: 'play_failure';
+        defaultFailureCount: number;
+    } | {
+        kind: 'play_scope';
+    } | {
+        kind: 'none';
+    };
+};
+type ProductNotificationPresentation = {
+    title: string;
+    summary: NotificationText;
+    details: NotificationText[];
+    targetUrl: string;
+    subjectKind: string;
+    subjectId: string;
+};
+type ProductNotificationRuleInput = {
+    ruleKey: string;
+    groupKey: string;
+    notificationType: ConfigurableProductNotificationType;
+    threshold?: number;
+    playFailure?: ProductNotificationPlayFailureSettings;
+};
+type ProductNotificationRuleBase = Omit<ProductNotificationDefaultRule, 'trigger'>;
+declare function validateInsufficientCreditDisable(trigger: ProductNotificationTrigger): void;
+declare function validateFailedOutcome(trigger: ProductNotificationTrigger): void;
+/** One canonical registry owns every notification type's runtime and UI metadata. */
+declare const PRODUCT_NOTIFICATION_TYPE_REGISTRY: readonly [{
+    readonly id: "monitor.disabled.insufficient_credits";
+    readonly eventName: "monitor.lifecycle.changed";
+    readonly requiredFilter: {};
+    readonly allowedTriggers: ["state_transition"];
+    readonly catalog: {
+        readonly name: "Monitor disabled due to insufficient credits";
+        readonly category: "credits";
+        readonly description: "Notify when Deepline disables a Monitor because the workspace ran out of credits.";
+        readonly allowMultiple: false;
+        readonly editor: {
+            readonly kind: "none";
+        };
+    };
+    readonly rule: {
+        readonly conditionSubject: "workspace";
+        readonly rearm: {
+            readonly eventName: "credits.balance.changed";
+            readonly matches: (payload: ProductNotificationFacts) => boolean;
+        };
+        readonly create: (_input: ProductNotificationRuleInput, base: ProductNotificationRuleBase) => {
+            trigger: {
+                kind: "state_transition";
+                targetState: string;
+                reasonCode: string;
+            };
+            groupKey: string;
+            enabled: boolean;
+            repeatMode?: ProductNotificationRepeatMode | undefined;
+            conditionGeneration?: number | undefined;
+            ruleKey: string;
+            notificationType: string;
+            eventName: string;
+            eventFilter: ProductNotificationFacts;
+        };
+        readonly validate: typeof validateInsufficientCreditDisable;
+        readonly present: ({ payload }: {
+            payload: ProductNotificationFacts;
+            trigger: ProductNotificationTrigger;
+        }) => {
+            title: string;
+            summary: (string | {
+                workspace: true;
+            })[];
+            details: never[];
+            targetUrl: string;
+            subjectKind: string;
+            subjectId: string;
+        };
+    };
+}, {
+    readonly id: "play.disabled.insufficient_credits";
+    readonly eventName: "play.lifecycle.changed";
+    readonly requiredFilter: {};
+    readonly allowedTriggers: ["state_transition"];
+    readonly catalog: {
+        readonly name: "Play temporarily disabled due to insufficient credits";
+        readonly category: "credits";
+        readonly description: "Notify when Deepline temporarily disables a scheduled Play because the workspace ran out of credits. Future runs resume automatically once the workspace has enough credits.";
+        readonly allowMultiple: false;
+        readonly editor: {
+            readonly kind: "none";
+        };
+    };
+    readonly rule: {
+        readonly default: {
+            readonly ruleKey: "default.play_disabled";
+            readonly groupKey: "default";
+        };
+        readonly conditionSubject: "workspace";
+        readonly rearm: {
+            readonly eventName: "credits.balance.changed";
+            readonly matches: (payload: ProductNotificationFacts) => boolean;
+        };
+        readonly create: (_input: ProductNotificationRuleInput, base: ProductNotificationRuleBase) => {
+            trigger: {
+                kind: "state_transition";
+                targetState: string;
+                reasonCode: string;
+            };
+            groupKey: string;
+            enabled: boolean;
+            repeatMode?: ProductNotificationRepeatMode | undefined;
+            conditionGeneration?: number | undefined;
+            ruleKey: string;
+            notificationType: string;
+            eventName: string;
+            eventFilter: ProductNotificationFacts;
+        };
+        readonly validate: typeof validateInsufficientCreditDisable;
+        readonly present: ({ payload }: {
+            payload: ProductNotificationFacts;
+            trigger: ProductNotificationTrigger;
+        }) => {
+            title: string;
+            summary: (string | {
+                workspace: true;
+            })[];
+            details: string[];
+            targetUrl: string;
+            subjectKind: string;
+            subjectId: string;
+        };
+    };
+}, {
+    readonly id: "usage.monthly.limit_reached";
+    readonly eventName: "credits.usage.recorded";
+    readonly requiredFilter: {};
+    readonly allowedTriggers: ["threshold_crossing"];
+    readonly catalog: {
+        readonly name: "Usage limit reached";
+        readonly category: "credits";
+        readonly description: "Notify when monthly usage reaches the workspace limit.";
+        readonly allowMultiple: false;
+        readonly editor: {
+            readonly kind: "none";
+        };
+    };
+    readonly rule: {
+        readonly default: {
+            readonly ruleKey: "default.usage_limit_reached";
+            readonly groupKey: "default";
+        };
+        readonly conditionSubject: "workspace";
+        readonly create: (_input: ProductNotificationRuleInput, base: ProductNotificationRuleBase) => {
+            trigger: {
+                kind: "threshold_crossing";
+                direction: "at_or_above";
+                threshold: number;
+                unit: string;
+            };
+            groupKey: string;
+            enabled: boolean;
+            repeatMode?: ProductNotificationRepeatMode | undefined;
+            conditionGeneration?: number | undefined;
+            ruleKey: string;
+            notificationType: string;
+            eventName: string;
+            eventFilter: ProductNotificationFacts;
+        };
+        readonly validate: (trigger: ProductNotificationTrigger) => void;
+        readonly present: ({ payload }: {
+            payload: ProductNotificationFacts;
+            trigger: ProductNotificationTrigger;
+        }) => {
+            title: string;
+            summary: (string | {
+                workspace: true;
+            })[];
+            details: (string | {
+                strong: string;
+            })[][];
+            targetUrl: string;
+            subjectKind: string;
+            subjectId: string;
+        };
+    };
+}, {
+    readonly id: "credits.low";
+    readonly eventName: "credits.balance.changed";
+    readonly requiredFilter: {};
+    readonly allowedTriggers: ["threshold_crossing"];
+    readonly catalog: {
+        readonly name: "Low credit warning";
+        readonly category: "credits";
+        readonly description: "Notify when the workspace credit balance crosses below a threshold.";
+        readonly allowMultiple: false;
+        readonly editor: {
+            readonly kind: "threshold";
+            readonly label: "Credit threshold";
+            readonly defaultThreshold: 10;
+            readonly minimum: 0;
+        };
+    };
+    readonly rule: {
+        readonly default: {
+            readonly ruleKey: "default.low_credits";
+            readonly groupKey: "default";
+        };
+        readonly conditionSubject: "workspace";
+        readonly create: (input: ProductNotificationRuleInput, base: ProductNotificationRuleBase, editor: {
+            kind: "threshold";
+            label: string;
+            defaultThreshold: number;
+            minimum: number;
+            maximum?: number;
+            suffix?: string;
+            /**
+             * When set, editors show and accept `remainingOf - threshold` (for
+             * example percent remaining) while the stored trigger stays in the
+             * runtime's "used" terms. Bounds and defaults are stored values.
+             */
+            remainingOf?: number;
+        } | {
+            kind: "play_failure";
+            defaultFailureCount: number;
+        } | {
+            kind: "play_scope";
+        } | {
+            kind: "none";
+        }) => {
+            trigger: {
+                kind: "threshold_crossing";
+                direction: "below";
+                threshold: number;
+                unit: string;
+            };
+            groupKey: string;
+            enabled: boolean;
+            repeatMode?: ProductNotificationRepeatMode | undefined;
+            conditionGeneration?: number | undefined;
+            ruleKey: string;
+            notificationType: string;
+            eventName: string;
+            eventFilter: ProductNotificationFacts;
+        };
+        readonly validate: (trigger: ProductNotificationTrigger) => void;
+        readonly present: ({ payload, trigger }: {
+            payload: ProductNotificationFacts;
+            trigger: ProductNotificationTrigger;
+        }) => {
+            title: string;
+            summary: (string | {
+                workspace: true;
+            })[];
+            details: (string | {
+                strong: string;
+            })[][];
+            targetUrl: string;
+            subjectKind: string;
+            subjectId: string;
+        };
+    };
+}, {
+    readonly id: "usage.monthly.nearing_limit";
+    readonly eventName: "credits.usage.recorded";
+    readonly requiredFilter: {};
+    readonly allowedTriggers: ["threshold_crossing"];
+    readonly catalog: {
+        readonly name: "Usage limit warning";
+        readonly category: "credits";
+        readonly description: "Notify when only a configurable percentage of the monthly usage limit remains.";
+        readonly allowMultiple: false;
+        readonly editor: {
+            readonly kind: "threshold";
+            readonly label: "Remaining usage";
+            readonly defaultThreshold: 90;
+            readonly minimum: 1;
+            readonly maximum: 99;
+            readonly suffix: "%";
+            readonly remainingOf: 100;
+        };
+    };
+    readonly rule: {
+        readonly conditionSubject: "workspace";
+        readonly create: (input: ProductNotificationRuleInput, base: ProductNotificationRuleBase, editor: {
+            kind: "threshold";
+            label: string;
+            defaultThreshold: number;
+            minimum: number;
+            maximum?: number;
+            suffix?: string;
+            /**
+             * When set, editors show and accept `remainingOf - threshold` (for
+             * example percent remaining) while the stored trigger stays in the
+             * runtime's "used" terms. Bounds and defaults are stored values.
+             */
+            remainingOf?: number;
+        } | {
+            kind: "play_failure";
+            defaultFailureCount: number;
+        } | {
+            kind: "play_scope";
+        } | {
+            kind: "none";
+        }) => {
+            trigger: {
+                kind: "threshold_crossing";
+                direction: "at_or_above";
+                threshold: number;
+                unit: string;
+            };
+            groupKey: string;
+            enabled: boolean;
+            repeatMode?: ProductNotificationRepeatMode | undefined;
+            conditionGeneration?: number | undefined;
+            ruleKey: string;
+            notificationType: string;
+            eventName: string;
+            eventFilter: ProductNotificationFacts;
+        };
+        readonly validate: (trigger: ProductNotificationTrigger) => void;
+        readonly present: ({ payload, trigger }: {
+            payload: ProductNotificationFacts;
+            trigger: ProductNotificationTrigger;
+        }) => {
+            title: string;
+            summary: (string | {
+                workspace: true;
+            })[];
+            details: (string | {
+                strong: string;
+            })[][];
+            targetUrl: string;
+            subjectKind: string;
+            subjectId: string;
+        };
+    };
+}, {
+    readonly id: "play.failed";
+    readonly eventName: "play.run.completed";
+    readonly requiredFilter: {
+        readonly outcome: "failed";
+    };
+    readonly allowedTriggers: ["each_match", "consecutive_outcomes"];
+    readonly catalog: {
+        readonly name: "Play failed";
+        readonly category: "plays";
+        readonly description: "Notify for all, scheduled, webhook-triggered, or specific Play failures.";
+        readonly allowMultiple: true;
+        readonly editor: {
+            readonly kind: "play_failure";
+            readonly defaultFailureCount: 1;
+        };
+    };
+    readonly rule: {
+        readonly create: (input: ProductNotificationRuleInput, base: ProductNotificationRuleBase) => {
+            eventFilter: ProductNotificationFacts;
+            repeatMode: "on_enter" | "every_match";
+            trigger: {
+                kind: "each_match";
+                count?: undefined;
+                outcome?: undefined;
+                maxLookback?: undefined;
+            } | {
+                kind: "consecutive_outcomes";
+                count: number;
+                outcome: string;
+                maxLookback: number;
+            };
+            groupKey: string;
+            enabled: boolean;
+            conditionGeneration?: number | undefined;
+            ruleKey: string;
+            notificationType: string;
+            eventName: string;
+        };
+        readonly validate: typeof validateFailedOutcome;
+        readonly present: ({ payload }: {
+            payload: ProductNotificationFacts;
+            trigger: ProductNotificationTrigger;
+        }) => ProductNotificationPresentation;
+    };
+}, {
+    readonly id: "play.succeeded";
+    readonly eventName: "play.run.completed";
+    readonly requiredFilter: {
+        readonly outcome: "succeeded";
+    };
+    readonly allowedTriggers: ["each_match"];
+    readonly catalog: {
+        readonly name: "Play succeeded";
+        readonly category: "plays";
+        readonly description: "Notify for all, scheduled, webhook-triggered, or specific Play successes.";
+        readonly allowMultiple: true;
+        readonly editor: {
+            readonly kind: "play_scope";
+        };
+    };
+    readonly rule: {
+        readonly create: (input: ProductNotificationRuleInput, base: ProductNotificationRuleBase) => {
+            eventFilter: ProductNotificationFacts;
+            repeatMode: "every_match";
+            trigger: {
+                kind: "each_match";
+            };
+            groupKey: string;
+            enabled: boolean;
+            conditionGeneration?: number | undefined;
+            ruleKey: string;
+            notificationType: string;
+            eventName: string;
+        };
+        readonly present: ({ payload }: {
+            payload: ProductNotificationFacts;
+            trigger: ProductNotificationTrigger;
+        }) => ProductNotificationPresentation;
+    };
+}, {
+    readonly id: "webhook.delivery.failed";
+    readonly eventName: "webhook.delivery.completed";
+    readonly requiredFilter: {
+        readonly outcome: "failed";
+    };
+    readonly allowedTriggers: ["each_match", "consecutive_outcomes"];
+    readonly catalog: undefined;
+    readonly rule: {
+        readonly validate: typeof validateFailedOutcome;
+        readonly present: ({ payload }: {
+            payload: ProductNotificationFacts;
+            trigger: ProductNotificationTrigger;
+        }) => ProductNotificationPresentation;
+    };
+}, {
+    readonly id: "webhook.delivery.succeeded";
+    readonly eventName: "webhook.delivery.completed";
+    readonly requiredFilter: {
+        readonly outcome: "succeeded";
+    };
+    readonly allowedTriggers: ["each_match"];
+    readonly catalog: undefined;
+    readonly rule: {
+        readonly present: ({ payload }: {
+            payload: ProductNotificationFacts;
+            trigger: ProductNotificationTrigger;
+        }) => ProductNotificationPresentation;
+    };
+}];
+type ConfigurableProductNotificationRegistration = Extract<(typeof PRODUCT_NOTIFICATION_TYPE_REGISTRY)[number], {
+    catalog: ProductNotificationTypeCatalogMetadata;
+}>;
+type ConfigurableProductNotificationType = ConfigurableProductNotificationRegistration['id'];
+type ProductNotificationTypeCatalogItem = ProductNotificationTypeCatalogMetadata & {
+    id: ConfigurableProductNotificationType;
+};
+type ProductNotificationPlayFailureSettings = {
+    scope: 'all' | 'cron' | 'webhook' | 'specific';
+    playId?: string;
+    playName?: string;
+    failureCount: number;
+};
+
 /**
  * Options for constructing a {@link DeeplineClient} or connecting via {@link Deepline.connect}.
  *
@@ -213,6 +836,17 @@ interface DeeplineClientOptions {
     timeout?: number;
     /** Maximum retry attempts for transient failures (network errors, 429s). Default: `3`. */
     maxRetries?: number;
+    /**
+     * Extra request headers attached to every request this client sends.
+     *
+     * They are merged *after* the headers the transport derives from the
+     * environment, so an explicit header replaces the env-derived one. Header
+     * names match case-insensitively and are normalized to lowercase.
+     *
+     * This is transport plumbing only: the server still authorizes every
+     * internal header it honors.
+     */
+    headers?: Record<string, string>;
 }
 /**
  * Fully resolved configuration used internally by the SDK.
@@ -228,6 +862,12 @@ interface ResolvedConfig {
     timeout: number;
     /** Max retry count for transient failures. */
     maxRetries: number;
+    /**
+     * Caller-supplied headers merged over the env-derived headers on every
+     * request. Absent unless the caller passed
+     * {@link DeeplineClientOptions.headers}.
+     */
+    headers?: Record<string, string>;
 }
 /** Column metadata returned by a customer data query. */
 interface CustomerDbColumn {
@@ -912,8 +1552,9 @@ interface PlayStatus {
     /**
      * Projected settled-charge billing for the run. Returned by `runs.get`.
      * `totalCredits`/`providerEvents` describe THIS run only; `rollup` (present
-     * with `--full`) carries the true subtree cost including ctx.runPlay children.
-     * Deepline credits only — provider spend is never exposed.
+     * with `--full`) carries the true subtree cost including independently
+     * executing ctx.runPlayAsync descendants. Deepline credits only — provider
+     * spend is never exposed.
      */
     billing?: RunBillingSummary;
     /**
@@ -925,13 +1566,25 @@ interface PlayStatus {
     billingChildCredits?: number;
     /** True when the child-run billing rollup could not be fully resolved. */
     billingRollupIncomplete?: boolean;
-    /** Durable summaries of ctx.runPlay children, returned by `runs.get --full`. */
+    /** Durable summaries of ctx.runPlayAsync children, returned by `runs.get --full`. */
     childRuns?: ChildRunSummary[];
+    /**
+     * Child Runs grouped by the authored ctx.runPlayAsync launch key. `complete`
+     * is false when the bounded response is a lower bound rather than the full
+     * direct-child set; use each opaque `runId` to retrieve a child Run.
+     */
+    childRunProjection?: AsyncChildRunProjection;
 }
-/** One ctx.runPlay child run exposed on the parent's `--full` payload. */
+/** One ctx.runPlayAsync child Run exposed on the parent's `--full` payload. */
 interface ChildRunSummary {
     runId: string;
     playName?: string | null;
+    /** Authored ctx.runPlayAsync key; stable across row fanout. */
+    launchKey?: string | null;
+    /** Opaque durable identity for one authored invocation. */
+    invocationKey?: string | null;
+    /** Whether this child uses root-owned Deepline billing attribution. */
+    rootBillingOwned?: boolean;
     status: string;
     parentRunId?: string | null;
     rootRunId?: string | null;
@@ -939,6 +1592,29 @@ interface ChildRunSummary {
     startedAt?: number | null;
     finishedAt?: number | null;
 }
+interface AsyncChildRunStatusCounts {
+    total: number;
+    queued: number;
+    active: number;
+    waiting: number;
+    succeeded: number;
+    failed: number;
+    cancelled: number;
+    unknown: number;
+}
+interface AsyncChildRunLaunchProjection {
+    launchKey: string | null;
+    playName: string | null;
+    counts: AsyncChildRunStatusCounts;
+    children: ChildRunSummary[];
+}
+interface AsyncChildRunProjection {
+    kind: 'async_child_runs';
+    returnedCount: number;
+    complete: boolean;
+    counts: AsyncChildRunStatusCounts;
+    launches: AsyncChildRunLaunchProjection[];
+}
 /**
  * Rolled-up billing for a run subtree, projected from settled Charge Lifecycle
  * facts. Deepline credits only — never provider spend.
@@ -1217,6 +1893,21 @@ interface PlayDefinitionDetail {
     /** Compatibility field for older readers. */
     currentPublishedVersion?: number | null;
 }
+type PlayCostEstimate = {
+    status: 'available';
+    source: 'observed' | 'static';
+    unit: 'row' | 'run';
+    lowCredits: number;
+    highCredits: number;
+    sampleRunCount: number;
+    basedOnRunId: string | null;
+    modelVersion: string;
+} | {
+    status: 'unavailable';
+    reason: 'ambiguous_output_unit' | 'unbounded_loop' | 'unresolved_tool' | 'mixed_run_and_row_costs';
+    message: string;
+    modelVersion: string;
+};
 interface PlayListItem {
     playKey?: string;
     reference?: string;
@@ -1246,6 +1937,7 @@ interface PlayListItem {
     liveRevision?: PlayRevisionSummary | null;
     aliases?: string[];
     triggerStatus?: PlayTriggerStatus;
+    costEstimate?: PlayCostEstimate;
 }
 /** Additive live trigger state shared by list, get, and describe. */
 interface PlayTriggerStatus {
@@ -1300,6 +1992,15 @@ interface ProductNotification {
     lastTestStatus?: string;
     lastErrorMessage?: string;
 }
+interface ProductNotificationConfigurationResponse {
+    configuration: EffectiveProductNotificationConfiguration;
+    catalog: readonly ProductNotificationTypeCatalogItem[];
+    slackConnection: {
+        connected: boolean;
+        status: string;
+        connectionId?: string;
+    };
+}
 interface PlayDescription {
     name: string;
     /** Stable registry key. Same value `plays list` reports for this play. */
@@ -1919,134 +2620,6 @@ type MonitorControls = {
  */
 declare function defineMonitor<TPayload extends MonitorPayload = MonitorPayload>(definition: MonitorDefinition<TPayload>): MonitorDefinition<TPayload>;
 
-/**
- * The fleet member ceiling, mirrored — deliberately a literal.
- *
- * The canonical declaration is shared_libs/monitors/monitor-fleet-limits.ts,
- * which the Convex commit mutation reads to size its transaction. This package
- * cannot import it: the workspace-architecture ratchet forbids NEW shared_libs
- * imports from packages absolutely (only relocations of pre-existing edges
- * pass CI), because shared_libs is being migrated into workspace packages.
- * Until a monitors package exists, the two copies are held equal by
- * tests/lib/monitors/monitor-fleet-limits-mirror.test.ts — change one without
- * the other and that test names both files.
- */
-declare const MONITOR_FLEET_MAX_MEMBERS = 1000;
-declare const MONITOR_FLEET_FRONTIER_MAX_ROWS = 10000;
-/**
- * Fleet definitions are admitted once and executed many times.  Keep the
- * edition beside the definition just as Plays keep their authoring-contract
- * edition: a future syntax change can add a reader without reinterpreting a
- * stored Fleet under new rules.
- */
-declare const MONITOR_FLEET_AUTHORING_CONTRACT_EDITION: 1;
-declare const SUPPORTED_MONITOR_FLEET_AUTHORING_CONTRACT_EDITIONS: readonly [1];
-type MonitorFleetAuthoringContractEdition = (typeof SUPPORTED_MONITOR_FLEET_AUTHORING_CONTRACT_EDITIONS)[number];
-declare const MONITOR_FLEET_AUTHORING_CONTRACT_CHANGELOG: readonly [{
-    readonly edition: 1;
-    readonly changed: "Initial Fleet JSON contract: bounded sticky table membership, one daily sync, and a seven-day removal grace.";
-    readonly compatibilityOwner: "Monitors Runtime";
-    readonly newWritesEnd: null;
-    readonly readerRemoval: null;
-}];
-/**
- * Public, machine-readable guidance for every Monitor Fleet authoring
- * surface. SDK clients may render this directly; the CLI uses the same fixed
- * policy values in its help rather than maintaining another contract.
- */
-declare const MONITOR_FLEET_DOCUMENTATION: {
-    readonly summary: "A Monitor Fleet keeps one bounded, sticky set of ordinary monitors aligned with Customer DB rows.";
-    readonly authoredFields: {
-        readonly id: "Stable lowercase fleet id used by sync, get, and deactivate.";
-        readonly source: "Customer DB table, unique row key, and optional equality filters that select candidate rows.";
-        readonly member: "Ordinary monitor tool, stable key template, and payload evaluated for each selected source row.";
-        readonly selection: "Deterministic ranking and an active-member limit between 1 and 1,000.";
-    };
-    readonly fixedPolicy: {
-        readonly cadence: "daily";
-        readonly membership: "sticky";
-        readonly removalGrace: "7d";
-        readonly onRemoved: "deactivate";
-        readonly ownership: "A Fleet may adopt a same-tool ordinary monitor with its deterministic member key. The first Fleet claim wins; another Fleet or a different tool receives a conflict.";
-        readonly billing: "No Fleet fee, permit, or renewal. Dry-run reports ordinary monitor lifecycle charges due now.";
-    };
-    readonly stickyMembership: "Ranking fills vacancies but never replaces a current member merely because another row ranks higher.";
-    readonly columnExpression: "Use { \"$fleet\": \"column\", \"name\": \"column_name\" } in a member key or payload to read a value from each source row.";
-};
-type MonitorFleetColumn = {
-    $fleet: 'column';
-    name: string;
-};
-type MonitorFleetTemplate = {
-    $fleet: 'template';
-    parts: Array<string | MonitorFleetColumn>;
-};
-type MonitorFleetExpression = MonitorFleetColumn | MonitorFleetTemplate;
-type MonitorFleetDefinition = {
-    /** Stable lowercase fleet id, used by CLI and API lifecycle commands. */
-    id: string;
-    /** Customer DB rows that may become members. */
-    source: {
-        kind: 'customer_db_table';
-        schema: string;
-        table: string;
-        key: {
-            column: string;
-            type: 'text' | 'uuid' | 'int4' | 'int8';
-        };
-        where?: Record<string, string | number | boolean | null>;
-    };
-    /** One ordinary monitor definition, evaluated once for each selected row. */
-    member: {
-        tool: string;
-        key: MonitorFleetTemplate;
-        payload: Record<string, unknown>;
-    };
-    /**
-     * Bounded deterministic candidate selection. Membership is intentionally
-     * sticky: ranking chooses vacant slots but does not replace existing members
-     * merely because another row's score changed.
-     */
-    selection: {
-        limit: number;
-        orderBy: Array<{
-            column: string;
-            direction: 'asc' | 'desc';
-        }>;
-        membership: 'sticky';
-    };
-};
-type MonitorFleetContractIssue = {
-    path: string;
-    code: string;
-    message: string;
-};
-/** The durable, validated snapshot that a Fleet sync is allowed to execute. */
-type AdmittedMonitorFleetAuthoringContract = {
-    edition: MonitorFleetAuthoringContractEdition;
-    definition: MonitorFleetDefinition;
-};
-type MonitorFleetAuthoringContractResult = {
-    valid: boolean;
-    contract?: AdmittedMonitorFleetAuthoringContract;
-    issues: MonitorFleetContractIssue[];
-};
-declare function fleetColumn(name: string): MonitorFleetColumn;
-declare function fleetKey(...parts: Array<string | MonitorFleetColumn>): MonitorFleetTemplate;
-declare function defineMonitorFleet<const T extends MonitorFleetDefinition>(definition: T): T;
-declare function validateMonitorFleetDefinition(value: unknown): {
-    valid: boolean;
-    definition?: MonitorFleetDefinition;
-    issues: MonitorFleetContractIssue[];
-};
-/**
- * Compile JSON into the exact authoring snapshot persisted by a Fleet.  This
- * does not inspect the Customer DB or provider; use
- * `fleets sync --file <fleet.json> --dry-run` for that environment-aware
- * preflight, which returns the real plan and the credits due.
- */
-declare function admitMonitorFleetAuthoringContract(value: unknown, edition?: number): MonitorFleetAuthoringContractResult;
-
 interface PlayStagedFileRef {
     storageKind: 'r2';
     storageKey: string;
@@ -2124,6 +2697,28 @@ type UpdateNotificationInput = {
     name: string;
     eventTypes: string[];
 } & SlackNotificationTarget);
+type CreateNotificationGroupInput = {
+    name: string;
+    targets: string[];
+    legacyEvents?: string[];
+    dryRun?: boolean;
+};
+type CreateNotificationGroupResult = {
+    mode: 'dry_run';
+    compatibilityMode: boolean;
+    name: string;
+    targets: string[];
+    legacyEvents: string[];
+} | {
+    mode: 'legacy';
+    notification: unknown;
+} | {
+    mode: 'native';
+    groupKey: string;
+    targets: string[];
+    group: EffectiveProductNotificationGroup;
+    destinations: EffectiveProductNotificationDestination[];
+};
 type IngestionStorageRepairResult = {
     status?: 'repaired';
     connection_grants: {
@@ -2226,6 +2821,32 @@ type RunsListOptions = {
     /** Zero-based page offset. Requires `play` because status-only inventory is not paginated. */
     offset?: number;
 };
+/** One server page; legacy runs.list continues to return an array. */
+type RunsListPage = {
+    runs: PlayRunListItem[];
+    total?: number;
+    offset?: number;
+    limit?: number;
+    hasMore?: boolean;
+};
+type PlaysListOptions = {
+    origin?: 'prebuilt' | 'owned';
+    grep?: string;
+    /**
+     * @deprecated Grep is always evaluated by the Convex full-text index.
+     * This retained option is ignored for source compatibility.
+     */
+    grepMode?: 'all' | 'any' | 'phrase';
+    categories?: string | string[];
+    includeToolCategories?: boolean;
+    includeArchived?: boolean;
+    includeCostEstimates?: boolean;
+};
+type PlaysListPage = {
+    plays: PlayListItem[];
+    cursor: string | null;
+    hasMore: boolean;
+};
 /** Options for `client.runs.get(...)`. */
 type RunsGetOptions = {
     /** Return the raw status payload instead of the compact package. */
@@ -2334,12 +2955,16 @@ type PlaySecretMetadata = {
     updatedAt: number;
     lastUsedAt?: number;
 };
+type PlaySecretCheck = {
+    ok: boolean;
+    name: string;
+    playName: string | null;
+    reason: 'active' | 'missing' | 'disabled' | 'empty' | 'invalid_version';
+    secret: PlaySecretMetadata | null;
+};
 /**
- * Public runs namespace exposed as `client.runs`.
- *
- * This namespace mirrors the canonical `/api/v2/runs` resource family and is
- * the preferred low-level surface for polling, streaming, stopping, reading
- * logs, and exporting durable dataset rows.
+ * `client.runs` mirrors `/api/v2/runs`: the preferred low-level surface for
+ * polling, streaming, stopping, reading logs, and exporting durable dataset rows.
  *
  * @sdkReference client 020 client.runs
  */
@@ -2367,6 +2992,8 @@ type RunsNamespace = {
     }>;
     /** List runs for one play, optionally filtered by status. */
     list: (options: RunsListOptions) => Promise<PlayRunListItem[]>;
+    /** Read one run page with total, offset, limit and completeness metadata. */
+    listPage: (options: RunsListOptions) => Promise<RunsListPage>;
     /** Stream run events and return the latest/terminal run status. */
     tail: (runId: string, options?: RunsTailOptions) => Promise<PlayStatus>;
     /** Fetch persisted log lines for a run. */
@@ -2604,6 +3231,58 @@ type MonitorFleetWaitOptions = {
      */
     until?: 'converged' | 'deactivated';
 };
+/** A durable monitor batch can name a small key set, a query target, or one Fleet. */
+type MonitorBatchScope = {
+    kind: 'keys';
+    monitorKeys: string[];
+} | {
+    kind: 'target';
+    target: 'all' | 'all-active' | 'billing-suspended' | 'needs-repair';
+} | {
+    kind: 'fleet';
+    fleetId: string;
+};
+type MonitorBatchExistingSubmitOptions = {
+    kind: 'audit' | 'deactivate' | 'reactivate' | 'repair';
+    scope: MonitorBatchScope;
+    dryRun?: boolean;
+    /** Required for deactivate; it is the declared reason shown by health/UI. */
+    deactivationReason?: string;
+    /** Stable retry key. Reusing it joins the original durable operation. */
+    idempotencyKey: string;
+};
+/** Complete definitions, one JSON object per line; uploaded as bounded shards. */
+type MonitorBatchDeploySubmitOptions = {
+    kind: 'deploy';
+    manifestNdjson: string;
+    dryRun?: boolean;
+    /** Stable retry key. Reusing it joins the same content-addressed manifest. */
+    idempotencyKey: string;
+};
+type MonitorBatchSubmitOptions = MonitorBatchExistingSubmitOptions | MonitorBatchDeploySubmitOptions;
+type MonitorBatchOperationResult = {
+    ok?: boolean;
+    rejoined?: boolean;
+    operation: {
+        runId: string;
+        kind: 'audit' | 'deactivate' | 'reactivate' | 'deploy' | 'repair';
+        state: 'running' | 'retry_scheduled' | 'completed' | 'failed';
+        dryRun: boolean;
+        scope: unknown;
+        submittedAt: number;
+        updatedAt: number;
+        deactivationReason?: string;
+        nextAttemptAt?: number;
+        completedAt?: number;
+        summary?: Record<string, unknown>;
+        lastError?: string;
+    };
+    results?: {
+        page: Array<Record<string, unknown>>;
+        isDone: boolean;
+        continueCursor: string;
+    };
+};
 type MonitorFleetsNamespace = {
     /**
      * Create, update, or re-plan a fleet. Pass a definition to admit new source
@@ -2621,6 +3300,12 @@ type MonitorFleetsNamespace = {
     /** Poll the fleet until the server reports a terminal status (or the timeout elapses). */
     waitForConvergence: (fleetId: string, options?: MonitorFleetWaitOptions) => Promise<MonitorFleetResult>;
 };
+type MonitorBatchNamespace = {
+    submit: (options: MonitorBatchSubmitOptions) => Promise<MonitorBatchOperationResult>;
+    get: (operationId: string, options?: {
+        cursor?: string | null;
+    }) => Promise<MonitorBatchOperationResult>;
+};
 /**
  * Delivery and convergence health for a scope, from
  * `GET /api/v2/monitors/health`.
@@ -2638,6 +3323,16 @@ type MonitorsHealth = {
     scanned: number;
     /** True when the scope was larger than one bounded read; counts are partial. */
     truncated: boolean;
+    /**
+     * A durable whole-scope snapshot is rebuilding. Counts remain intentionally
+     * partial until it completes; older servers omit this additive field.
+     */
+    refresh?: {
+        state: 'running' | 'completed';
+        started_at: number;
+        updated_at: number;
+        completed_at: number | null;
+    };
     desired: {
         active: number;
         inactive: number;
@@ -2652,6 +3347,11 @@ type MonitorsHealth = {
     };
     converged: number;
     needs_repair: number;
+    /**
+     * Unknown records without an upstream resource id. Use the exact inventory
+     * reconciler to align them; ordinary repair never guesses an identity.
+     */
+    alignment_required: number;
     /** Observed active, but nothing delivered inside `silent_window_days`. */
     silent: number;
     silent_window_days: number;
@@ -2668,6 +3368,24 @@ type MonitorsHealth = {
         observed_at: number | null;
         provider_resource_id: string | null;
     }>;
+    /** Bounded current durable monitor work, if the server supports it. */
+    batch_operations?: Array<{
+        run_id: string;
+        kind: 'audit' | 'deactivate' | 'reactivate' | 'repair' | 'deploy';
+        state: 'running' | 'retry_scheduled';
+        updated_at: number;
+        next_attempt_at?: number;
+        summary?: Record<string, unknown>;
+    }>;
+    /** Bounded sample explaining why normal audit did not settle the row. */
+    unaudited_monitors: Array<{
+        monitor_key: string;
+        tool: string;
+        observed: 'unknown' | null;
+        observed_at: number | null;
+        provider_resource_id: string | null;
+        reason: 'not_yet_audited' | 'missing_provider_resource_id' | 'provider_observation_unknown';
+    }>;
 };
 /** One bounded audit pass, from `POST /api/v2/monitors/audit`. */
 type MonitorsAuditResult = {
@@ -2796,11 +3514,15 @@ type MonitorsNamespace = {
     health: (options?: {
         fleetId?: string;
     }) => Promise<MonitorsHealth>;
+    /** Durable bulk audit/deactivation/reactivation/repair with retained progress. */
+    batch: MonitorBatchNamespace;
     /** Define, reconcile, and control table-backed monitor fleets. */
     fleets: MonitorFleetsNamespace;
 };
 /** One credit grant pool reported by the billing subscription status endpoint. */
 type BillingCreditPool = {
+    /** Stable grant identity; optional when talking to an older server. */
+    grant_id?: string;
     pool: string;
     credits_remaining: number;
     credits_granted: number;
@@ -2879,10 +3601,10 @@ type TargetBillingOperation = {
     next_action?: string | null;
 };
 type TargetBillingPlan = {
-    sku: 'payg-v1' | 'builder-v1' | 'team-v1';
+    sku: 'payg-v1' | 'builder-v1' | 'growth-v1' | 'growth-canary-v1' | 'team-v1';
     name: string;
     recurring_price_usd: number;
-    interval: 'month';
+    interval: 'month' | 'year';
     included_credits: number;
     purchased_credit_price_usd: number;
 };
@@ -2936,7 +3658,7 @@ type TargetBillingMutationResult = {
 };
 type TargetBillingPlanTransitionOptions = {
     action: 'start_or_change';
-    targetPlanSku: 'payg-v1' | 'builder-v1' | 'team-v1';
+    targetPlanSku: 'payg-v1' | 'builder-v1' | 'growth-v1' | 'growth-canary-v1' | 'team-v1';
     idempotencyKey: string;
 } | {
     action: 'cancel' | 'undo_cancel';
@@ -3016,7 +3738,12 @@ type WorkspaceCreateResult = {
     org_name: string;
     org_slug: string;
     plan_sku: 'payg-v1';
-    rate_policy_ref: 'payg-rates-v2';
+    /**
+     * The PAYG rate policy the workspace was provisioned onto, taken from the
+     * catalog revision its operation pinned: v4 bound payg-rates-v2, v5 binds
+     * the flat payg-rates-v3.
+     */
+    rate_policy_ref: 'payg-rates-v2' | 'payg-rates-v3';
     operation: {
         id: string;
         state: 'completed';
@@ -3161,6 +3888,14 @@ declare class DeeplineClient {
      * @returns Matching active secret metadata, or `null`.
      */
     checkSecret(name: string): Promise<PlaySecretMetadata | null>;
+    /** Check effective scope and active-version health without reading the value.
+     * Without playName, checks the organization-scoped secret only. With a Play
+     * name, an active Play secret takes precedence; a deleted/disabled Play
+     * secret falls back to the organization-scoped secret.
+     */
+    inspectSecret(name: string, options?: {
+        playName?: string;
+    }): Promise<PlaySecretCheck>;
     /**
      * List all available tools.
      *
@@ -3695,6 +4430,8 @@ declare class DeeplineClient {
      * ```
      */
     listRuns(options: RunsListOptions): Promise<PlayRunListItem[]>;
+    /** Read one run page without discarding server pagination metadata. */
+    listRunsPage(options: RunsListOptions): Promise<RunsListPage>;
     /**
      * Observe one run's live events. Uses the Convex Run Snapshot subscription
      * transport first (ADR-0008), then falls back to the canonical SSE stream
@@ -3799,19 +4536,19 @@ declare class DeeplineClient {
         reason?: string;
     }): Promise<StopAllPlayRunsResult>;
     /**
-     * List callable plays visible to the workspace.
+     * List one page of callable plays; grep retains exhaustive matching results.
+     * Use listPlaysPage to retain pagination metadata.
      *
      * Pass `origin: "prebuilt"` for Deepline-managed prebuilts or
      * `origin: "owned"` for org-owned plays.
      */
-    listPlays(options?: {
-        origin?: 'prebuilt' | 'owned';
-        grep?: string;
-        grepMode?: 'all' | 'any' | 'phrase';
-        categories?: string | string[];
-        includeToolCategories?: boolean;
-        includeArchived?: boolean;
-    }): Promise<PlayListItem[]>;
+    listPlays(options?: PlaysListOptions): Promise<PlayListItem[]>;
+    /** Read one bounded inventory page; cursor continues the same filters. */
+    listPlaysPage(options?: PlaysListOptions & {
+        limit?: number;
+        cursor?: string | null;
+    }): Promise<PlaysListPage>;
+    private requestPlaysPage;
     /** Set whether an org-owned Play sorts before unpinned Plays. */
     setPlayPinned(playName: string, pinned: boolean): Promise<{
         name: string;
@@ -3862,6 +4599,12 @@ declare class DeeplineClient {
     updateNotificationDlqDelivery(deliveryId: string, action: 'retry' | 'archive'): Promise<unknown>;
     /** List the workspace's named notification rules. */
     getNotifications(): Promise<ProductNotificationSettings>;
+    /** Read the group-based product-notification configuration and rule catalog. */
+    getNotificationConfiguration(): Promise<ProductNotificationConfigurationResponse>;
+    /** Atomically apply one retry-safe desired configuration change. */
+    changeNotificationConfiguration(expectedWorkspaceVersion: number, change: ProductNotificationConfigurationChange): Promise<Pick<ProductNotificationConfigurationResponse, 'configuration'>>;
+    /** Create one notification group and its destinations as a retry-safe unit. */
+    createNotificationGroup(input: CreateNotificationGroupInput): Promise<CreateNotificationGroupResult>;
     /** List Slack channels available to an already-connected Slack integration. */
     listNotificationChannels(query?: string): Promise<{
         identity: {
@@ -4170,6 +4913,12 @@ declare class DeeplineClient {
     readMonitorsHealth(options?: {
         fleetId?: string;
     }): Promise<MonitorsHealth>;
+    /** Submit durable monitor work; transport retries use the same idempotency key. */
+    submitMonitorBatch(options: MonitorBatchSubmitOptions): Promise<MonitorBatchOperationResult>;
+    /** Get durable batch progress and a bounded retained evidence page. */
+    getMonitorBatch(operationId: string, options?: {
+        cursor?: string | null;
+    }): Promise<MonitorBatchOperationResult>;
     /**
      * The deployable monitor tools catalog. Pass a tool id (positional or
      * `{ tool }`) to describe one tool's full payload/stream contract, or no tool
@@ -4640,7 +5389,13 @@ type PrebuiltPlayRef = {
     readonly playName: string;
     readonly name: string;
 };
-type PlayReferenceLike = PlayAuthoringReferenceLike;
+type PlayReferenceLike<TInput extends Record<string, unknown> = Record<string, unknown>> = PlayAuthoringReferenceLike<TInput>;
+/** Branded durable identity returned by ctx.runPlayAsync. */
+type PlayRunId = PlayRunId$1;
+/** Serializable reference to an independently scheduled Play Run. */
+type AsyncPlayRunRef = AsyncPlayRunRef$1;
+/** Author intent for an independently scheduled child Run. */
+type PlayAsyncCallOptions = PlayAuthoringAsyncCallOptions;
 
 type PlayReturnObject = PlayReturnObject$1;
 type PlayInputContract<TInput> = PlayAuthoringInputContract<TInput>;
@@ -5239,4 +5994,4 @@ declare function writeCsvOutputFile(rows: Array<Record<string, unknown>>, stem:
  */
 declare function extractSummaryFields(payload: unknown): Record<string, Scalar>;
 
-export { type AdmittedMonitorFleetAuthoringContract, AuthError, type BillingCreditPool, type BillingInvoiceEntry, type BillingInvoicesResult, type BillingNamespace, type BillingPaymentMethodSummary, type BillingSubscriptionCancelResult, type BillingSubscriptionStatus, type BillingTopUpResult, type ClearPlayHistoryRequest, type ClearPlayHistoryResult, type ColumnMap, type ColumnResolver, type ConditionalStepResolver, ConfigError, type CsvInput, type CsvOptions, type CustomerDbQueryResult, DEEPLINE_TOOL_CATEGORIES, type DatasetBuilder, type DatasetColumnDefinition, type DatasetColumnRunInput, type DbNamespace, Deepline, DeeplineClient, type DeeplineClientOptions, DeeplineContext, DeeplineError, type DeeplineNamedPlay, type DeeplinePlayRuntimeContext, type DeeplinePlaysNamespace, type DeeplineToolCategory, type DeeplineToolsNamespace, type DefinePlayConfig, type DefinedPlay, type FetchOptions, type FileInput, type IngestionStorageRepairResult, type LiveEventEnvelope, MONITOR_FLEET_AUTHORING_CONTRACT_CHANGELOG, MONITOR_FLEET_AUTHORING_CONTRACT_EDITION, MONITOR_FLEET_DOCUMENTATION, MONITOR_FLEET_FRONTIER_MAX_ROWS, MONITOR_FLEET_MAX_MEMBERS, type MonitorCheckResult, type MonitorControls, type MonitorDefinition, type MonitorDeleteResult, type MonitorDependents, type MonitorDeployResult, type MonitorDetail, type MonitorFleetAuthoringContractEdition, type MonitorFleetAuthoringContractResult, type MonitorFleetColumn, type MonitorFleetContractIssue, type MonitorFleetDeactivateOptions, type MonitorFleetDefinition, type MonitorFleetExpression, type MonitorFleetGetOptions, type MonitorFleetReactivateOptions, type MonitorFleetResult, type MonitorFleetStatus, type MonitorFleetSyncOptions, type MonitorFleetTemplate, type MonitorFleetWaitOptions, type MonitorFleetsNamespace, type MonitorListEntry, type MonitorPayload, type MonitorReactivateResult, type MonitorSpec, type MonitorUpdateChangeSummary, type MonitorUpdateResult, type MonitorsAccessStatus, type MonitorsAvailableOptions, type MonitorsAvailableResult, type MonitorsListOptions, type MonitorsListResult, type MonitorsNamespace, PLAY_BOOTSTRAP_COMPANY_FIELDS, PLAY_BOOTSTRAP_COMPANY_PROVIDER_CATEGORY, PLAY_BOOTSTRAP_CONTACT_FIELDS, PLAY_BOOTSTRAP_FINDER_KINDS, PLAY_BOOTSTRAP_OUTPUT_FIELD_BY_FINDER, PLAY_BOOTSTRAP_PEOPLE_PROVIDER_CATEGORY, PLAY_BOOTSTRAP_PROVIDER_CATEGORY_BY_FINDER, PLAY_BOOTSTRAP_SOURCE_KINDS, PLAY_BOOTSTRAP_STAGE_KINDS, PLAY_BOOTSTRAP_TEMPLATES, PROD_URL, type PlayActivityObservation, type PlayActivityState, type PlayActivityTarget, type PlayBindings, type PlayBootstrapEntityKind, type PlayBootstrapFinderKind, type PlayCallExecution, type PlayCallOptions, type PlayFetchResponse, type PlayInputContract, type PlayJob, type PlayListItem, type PlayLiveEvent, type PlayRevisionSummary, type PlayRunActionPackage, type PlayRunActivityProjection, type PlayRunDatasetActions, type PlayRunPackage, type PlayRunResult, type PlayRunStart, type PlaySheetRow, type PlaySheetRowsResult, type PlayStatus, type PlayStepProgramStep, type PrebuiltPlayRef, type PublishPlayVersionRequest, type PublishPlayVersionResult, RateLimitError, type ResolvedConfig, RunObserveTransportUnavailableError, type RunsListOptions, type RunsLogsOptions, type RunsLogsResult, type RunsNamespace, type RunsTailOptions, type RuntimeStepOptions, SDK_API_CONTRACT, SDK_VERSION, type SqlListenerDeclaration, type SqlListenerEvent, type SqlListenerOperation, type SqlQuery, type StartPlayRunRequest, type StepOptions, type StepProgram, type StepProgramResolver, type StepResolver, type StopPlayRunResult, type ToolDefinition, ToolExecuteResult, type ToolExecution, ToolExecutionError, ToolExecutionErrorOptions, type ToolExecutionRequest, type ToolMetadata, ToolRateLimitError, type ToolSearchOptions, type ToolSearchResult, type WorkspaceCreateResult, type WorkspacesNamespace, admitMonitorFleetAuthoringContract, defineInput, defineMonitor, defineMonitorFleet, definePlay, defineWorkflow, extractSummaryFields, fleetColumn, fleetKey, formatPlayBootstrapFinderKinds, formatPlayBootstrapFinderKindsForSentence, formatPlayBootstrapTemplates, getDefinedPlayMetadata, isPlayBootstrapFinderKind, isPlayBootstrapTemplate, resolveConfig, runIf, steps, tryConvertToList, validateMonitorFleetDefinition, writeCsvOutputFile, writeJsonOutputFile };
+export { type AsyncPlayRunRef, AuthError, type BillingCreditPool, type BillingInvoiceEntry, type BillingInvoicesResult, type BillingNamespace, type BillingPaymentMethodSummary, type BillingSubscriptionCancelResult, type BillingSubscriptionStatus, type BillingTopUpResult, type ClearPlayHistoryRequest, type ClearPlayHistoryResult, type ColumnMap, type ColumnResolver, type ConditionalStepResolver, ConfigError, type CreateNotificationGroupInput, type CreateNotificationGroupResult, type CsvInput, type CsvOptions, type CustomerDbQueryResult, DEEPLINE_TOOL_CATEGORIES, type DatasetBuilder, type DatasetColumnDefinition, type DatasetColumnRunInput, type DbNamespace, Deepline, DeeplineClient, type DeeplineClientOptions, DeeplineContext, DeeplineError, type DeeplineNamedPlay, type DeeplinePlayRuntimeContext, type DeeplinePlaysNamespace, type DeeplineToolCategory, type DeeplineToolsNamespace, type DefinePlayConfig, type DefinedPlay, type FetchOptions, type FileInput, type IngestionStorageRepairResult, type LiveEventEnvelope, type MonitorCheckResult, type MonitorControls, type MonitorDefinition, type MonitorDeleteResult, type MonitorDependents, type MonitorDeployResult, type MonitorDetail, type MonitorFleetDeactivateOptions, MonitorFleetDefinition, type MonitorFleetGetOptions, type MonitorFleetReactivateOptions, type MonitorFleetResult, type MonitorFleetStatus, type MonitorFleetSyncOptions, type MonitorFleetWaitOptions, type MonitorFleetsNamespace, type MonitorListEntry, type MonitorPayload, type MonitorReactivateResult, type MonitorSpec, type MonitorUpdateChangeSummary, type MonitorUpdateResult, type MonitorsAccessStatus, type MonitorsAvailableOptions, type MonitorsAvailableResult, type MonitorsListOptions, type MonitorsListResult, type MonitorsNamespace, PLAY_BOOTSTRAP_COMPANY_FIELDS, PLAY_BOOTSTRAP_COMPANY_PROVIDER_CATEGORY, PLAY_BOOTSTRAP_CONTACT_FIELDS, PLAY_BOOTSTRAP_FINDER_KINDS, PLAY_BOOTSTRAP_OUTPUT_FIELD_BY_FINDER, PLAY_BOOTSTRAP_PEOPLE_PROVIDER_CATEGORY, PLAY_BOOTSTRAP_PROVIDER_CATEGORY_BY_FINDER, PLAY_BOOTSTRAP_SOURCE_KINDS, PLAY_BOOTSTRAP_STAGE_KINDS, PLAY_BOOTSTRAP_TEMPLATES, PROD_URL, type PlayActivityObservation, type PlayActivityState, type PlayActivityTarget, type PlayAsyncCallOptions, type PlayBindings, type PlayBootstrapEntityKind, type PlayBootstrapFinderKind, type PlayCallExecution, type PlayCallOptions, type PlayCostEstimate, type PlayFetchResponse, type PlayInputContract, type PlayJob, type PlayListItem, type PlayLiveEvent, type PlayReferenceLike, type PlayRevisionSummary, type PlayRunActionPackage, type PlayRunActivityProjection, type PlayRunDatasetActions, type PlayRunId, type PlayRunPackage, type PlayRunResult, type PlayRunStart, type PlaySheetRow, type PlaySheetRowsResult, type PlayStatus, type PlayStepProgramStep, type PlaysListOptions, type PlaysListPage, type PrebuiltPlayRef, type PublishPlayVersionRequest, type PublishPlayVersionResult, RateLimitError, type ResolvedConfig, RunObserveTransportUnavailableError, type RunsListOptions, type RunsListPage, type RunsLogsOptions, type RunsLogsResult, type RunsNamespace, type RunsTailOptions, type RuntimeStepOptions, SDK_API_CONTRACT, SDK_VERSION, type SqlListenerDeclaration, type SqlListenerEvent, type SqlListenerOperation, type SqlQuery, type StartPlayRunRequest, type StepOptions, type StepProgram, type StepProgramResolver, type StepResolver, type StopPlayRunResult, type ToolDefinition, ToolExecuteResult, type ToolExecution, ToolExecutionError, ToolExecutionErrorOptions, type ToolExecutionRequest, type ToolMetadata, ToolRateLimitError, type ToolSearchOptions, type ToolSearchResult, type WorkspaceCreateResult, type WorkspacesNamespace, defineInput, defineMonitor, definePlay, defineWorkflow, extractSummaryFields, formatPlayBootstrapFinderKinds, formatPlayBootstrapFinderKindsForSentence, formatPlayBootstrapTemplates, getDefinedPlayMetadata, isPlayBootstrapFinderKind, isPlayBootstrapTemplate, resolveConfig, runIf, steps, tryConvertToList, writeCsvOutputFile, writeJsonOutputFile };