deepline 0.3.115 → 0.3.117

package/dist/bundling-sources/sdk/src/client.ts

@@ -867,10 +867,29 @@ export type MonitorsAvailableOptions = {
   compact?: boolean;
 };
 
+/**
+ * Stable customer-facing Monitor/Fleet state.
+ *
+ * Provider provisioning, cleanup, retries, and failures are Monitor Job
+ * progress and must never be added to this union. The `status` and `active`
+ * fields below are retained only as deprecated compatibility aliases for
+ * older API responses.
+ */
+export type MonitorState = 'active' | 'billing_suspended' | 'disabled';
+
+/** List filters accepted by the canonical state surface. */
+export type MonitorStateFilter = MonitorState | 'all';
+
+/** The pre-state list filter retained for installed-client compatibility. */
+export type LegacyMonitorStatusFilter = 'active' | 'inactive' | 'all';
+
 /** One deployed monitor row returned by `client.monitors.list(...)`. */
 export type MonitorListEntry = {
   key?: string;
   monitor_key?: string;
+  /** Canonical customer-facing lifecycle state. */
+  state?: MonitorState;
+  /** @deprecated Use state. `inactive` is projected as `disabled`. */
   status?: string;
   tool?: string;
   /** Generic provider-authored event category for this deployed monitor. */
@@ -900,7 +919,15 @@ export type MonitorsListResult = {
   /** @deprecated Use has_more. */
   is_truncated?: boolean;
   next_cursor?: string | null;
+  /** Canonical state filter echoed by newer servers. */
+  state_filter_applied?: MonitorStateFilter;
+  /** Canonical state counts. */
+  state_summary?: Array<{ state: MonitorState; count: number }>;
+  /** Whether state_summary counts this page or the full applied state filter. */
+  state_summary_scope?: 'page' | 'filter_total';
+  /** @deprecated Use state_filter_applied. */
   status_filter_applied?: string;
+  /** @deprecated Use state_summary. */
   status_summary?: Array<{ status: string; count: number }>;
   include_consumers?: boolean;
   [key: string]: unknown;
@@ -908,8 +935,10 @@ export type MonitorsListResult = {
 
 /** Options for `client.monitors.list(...)`. */
 export type MonitorsListOptions = {
-  /** active (default), disabled, or all. */
-  status?: string;
+  /** Canonical customer state filter; active is the default. */
+  state?: MonitorStateFilter;
+  /** @deprecated Use state. `inactive` remains accepted for old servers. */
+  status?: LegacyMonitorStatusFilter | (string & {});
   limit?: number | string;
   /** Page past a truncated result using a prior response's `next_cursor`. */
   cursor?: string;
@@ -941,6 +970,12 @@ export type MonitorSpec = {
 
 /** One deployed-monitor read. The server may add monitor-specific fields. */
 export type MonitorDetail = Record<string, unknown> & {
+  /** Canonical customer-facing lifecycle state. */
+  state?: MonitorState;
+  /** @deprecated Use state. */
+  status?: string;
+  /** @deprecated Use state. */
+  active?: boolean;
   monitor_spec?: MonitorSpec;
 };
 export type MonitorDependents = Record<string, unknown>;
@@ -991,21 +1026,122 @@ export type MonitorValidateResult = Record<string, unknown>;
 /**
  * Server-owned fleet response envelope.
  *
- * The server computes `status` (`converging` | `converged` | `degraded` |
- * `deactivating` | `deactivated`) and the SDK never recomputes it: a client
- * that derives its own verdict from counts drifts from the control plane the
- * moment the server changes what "converged" means.
+ * The server computes the canonical customer `state` and the SDK never
+ * recomputes it. Transitional convergence details remain in the owning Fleet
+ * Job; the deprecated `status` alias is retained only for installed clients.
  */
-export type MonitorFleetResult = Record<string, unknown>;
+export type MonitorFleetResult = Record<string, unknown> & {
+  /** Canonical customer-facing Fleet state. */
+  state?: MonitorState;
+  /** @deprecated Fleet operation/convergence status; use state + jobs. */
+  status?: string;
+};
+
+/** Standalone SDK mirror of the server-owned Monitor Job contract. */
+export const MONITOR_JOB_STATES = [
+  'queued',
+  'running',
+  'cancelling',
+  'succeeded',
+  'failed',
+  'cancelled',
+] as const;
+export type MonitorJobState = (typeof MONITOR_JOB_STATES)[number];
+
+export const MONITOR_JOB_PHASES = [
+  'queued',
+  'provider_create',
+  'provider_readback',
+  'reconciliation',
+  'completed',
+] as const;
+export type MonitorJobPhase = (typeof MONITOR_JOB_PHASES)[number];
+
+export const MONITOR_JOB_RECONCILIATION_STATES = [
+  'pending',
+  'aligned',
+  'partial',
+  'mismatched',
+] as const;
+export type MonitorJobReconciliationState =
+  (typeof MONITOR_JOB_RECONCILIATION_STATES)[number];
+
+export type MonitorJobProjection = {
+  id: string;
+  kind: 'batch_deploy' | 'fleet_deploy';
+  state: MonitorJobState;
+  phase: MonitorJobPhase;
+  target: {
+    monitor_key?: string;
+    batch_id?: string;
+    generation?: number;
+    fleet_id?: string;
+  };
+  counts: {
+    requested: number;
+    valid: number;
+    queued: number;
+    running: number;
+    created: number;
+    updated: number;
+    removed: number;
+    unchanged: number;
+    settled: number;
+    verified: number;
+    failed: number;
+    cancelled_before_start: number;
+  };
+  reconciliation: {
+    state: MonitorJobReconciliationState;
+    expected_bindings: number;
+    observed_bindings: number;
+    active_mismatches: number;
+    provider_only_matching_markers: number;
+    next?: string;
+  };
+  error?: string;
+};
 
-/** Shared response envelope for immutable batch and desired-set Monitor Jobs. */
-export type MonitorJobResult = Record<string, unknown>;
+export type MonitorNamedBatchProjection = {
+  id: string;
+  state: 'active' | 'stopped';
+  generation: number;
+  desired_count: number;
+  retained_count: number;
+  last_job_id: string;
+  updated_at: string;
+};
+
+/** Shared typed envelope for immutable batch and desired-set Monitor Jobs. */
+export type MonitorJobResult = {
+  ok?: boolean;
+  job?: MonitorJobProjection;
+  batch?: MonitorNamedBatchProjection;
+  logs?: Array<{
+    level: string;
+    phase: string;
+    message: string;
+    monitor_key?: string;
+    at: string;
+  }>;
+  replayed?: boolean;
+  already_terminal?: boolean;
+  next?: string;
+  [key: string]: unknown;
+};
 
 export type MonitorJobDeployOptions = {
   /** Stable retry key; the server binds it to the submitted immutable set. */
   idempotencyKey?: string;
 };
 
+export type MonitorLifecycleOptions = {
+  /** Return the plan without changing provider state. */
+  dryRun?: boolean;
+  /** Stable retry key for durable start/stop work. */
+  idempotencyKey?: string;
+};
+
 export type MonitorJobLogsOptions = { limit?: number };
 
 export type MonitorJobWaitOptions = {
@@ -1126,7 +1262,8 @@ export type MonitorBatchOperationResult = {
       | 'deactivate'
       | 'reactivate'
       | 'deploy'
-      | 'repair';
+      | 'repair'
+      | 'named_batch';
     state: 'running' | 'retry_scheduled' | 'completed' | 'failed' | 'cancelled';
     dryRun: boolean;
     scope: unknown;
@@ -1179,6 +1316,16 @@ export type MonitorFleetsNamespace = {
     fleetId: string,
     options?: MonitorFleetReactivateOptions,
   ) => Promise<MonitorFleetResult>;
+  /** Customer-facing alias for `reactivate`. */
+  start: (
+    fleetId: string,
+    options?: MonitorFleetReactivateOptions,
+  ) => Promise<MonitorFleetResult>;
+  /** Customer-facing alias for `deactivate`. */
+  stop: (
+    fleetId: string,
+    options?: MonitorFleetDeactivateOptions,
+  ) => Promise<MonitorFleetResult>;
   /** Poll the fleet until the server reports a terminal status (or the timeout elapses). */
   waitForConvergence: (
     fleetId: string,
@@ -1201,6 +1348,28 @@ export type MonitorBatchNamespace = {
   ) => Promise<MonitorBatchOperationResult>;
 };
 
+export type MonitorNamedBatchOptions = {
+  idempotencyKey?: string;
+  expectedGeneration?: number;
+};
+
+export type MonitorNamedBatchesNamespace = {
+  sync: (
+    batchId: string,
+    definitions: MonitorDefinition[],
+    options?: MonitorNamedBatchOptions,
+  ) => Promise<MonitorJobResult>;
+  start: (
+    batchId: string,
+    options?: Pick<MonitorNamedBatchOptions, 'idempotencyKey'>,
+  ) => Promise<MonitorJobResult>;
+  stop: (
+    batchId: string,
+    options?: Pick<MonitorNamedBatchOptions, 'idempotencyKey'>,
+  ) => Promise<MonitorJobResult>;
+  get: (batchId: string) => Promise<MonitorJobResult>;
+};
+
 /**
  * Delivery and convergence health for a scope, from
  * `GET /api/v2/monitors/health`.
@@ -1263,6 +1432,7 @@ export type MonitorsHealth = {
       | 'audit'
       | 'converge'
       | 'deactivate'
+      | 'named_batch'
       | 'reactivate'
       | 'repair'
       | 'deploy';
@@ -1371,7 +1541,14 @@ export type MonitorsNamespace = {
     definition: MonitorDefinition,
     options?: { dryRun?: boolean },
   ) => Promise<MonitorDeployResult>;
-  /** List deployed monitors (active by default). `includeConsumers` requires a limit of 20 or fewer. */
+  /** Set the desired definition for one stable monitor key. */
+  sync: (
+    definition: MonitorDefinition,
+    options?: MonitorLifecycleOptions,
+  ) => Promise<MonitorJobResult | MonitorDeployResult>;
+  /** List deployed monitors (active by default). Use `state` to filter the
+   * three customer states; `status` is retained for older servers.
+   * `includeConsumers` requires a limit of 20 or fewer. */
   list: (options?: MonitorsListOptions) => Promise<MonitorsListResult>;
   /** Fetch one deployed monitor by public key with bounded current listener health. */
   get: (key: string) => Promise<MonitorDetail>;
@@ -1399,6 +1576,16 @@ export type MonitorsNamespace = {
     key: string,
     options?: { dryRun?: boolean },
   ) => Promise<MonitorReactivateResult>;
+  /** Explicitly apply the retained definition for a stopped monitor. */
+  start: (
+    key: string,
+    options?: MonitorLifecycleOptions,
+  ) => Promise<MonitorJobResult | MonitorBatchOperationResult>;
+  /** Converge one monitor to inactive while retaining its definition. */
+  stop: (
+    key: string,
+    options?: MonitorLifecycleOptions,
+  ) => Promise<MonitorJobResult | MonitorBatchOperationResult>;
   /**
    * Re-read what the provider holds onto the monitors that claim it. Bounded
    * and idempotent: pass `cursor` back while `audit.cursor` is non-null.
@@ -1421,6 +1608,8 @@ export type MonitorsNamespace = {
   fleets: MonitorFleetsNamespace;
   /** Deploy an immutable one-off list through the common Monitor Job engine. */
   batch: MonitorBatchNamespace;
+  /** Reconcile and control a stable named static Batch. */
+  batches: MonitorNamedBatchesNamespace;
   /** Read, wait for, inspect, or cancel Monitor Jobs. */
   jobs: MonitorJobsNamespace;
 };
@@ -2373,6 +2562,10 @@ export class DeeplineClient {
         this.getMonitorsAvailable(toolIdOrOptions, options),
       check: (definition) => this.checkMonitor(definition),
       deploy: (definition, options) => this.deployMonitor(definition, options),
+      sync: (definition, options) =>
+        options?.dryRun
+          ? this.deployMonitor(definition, { dryRun: true })
+          : this.syncScalarMonitor(definition, options),
       list: (options) => this.listMonitors(options),
       get: (key) => this.getMonitor(key),
       test: (key, payload, options) =>
@@ -2382,6 +2575,28 @@ export class DeeplineClient {
       update: (key, patch) => this.updateMonitor(key, patch),
       delete: (key, options) => this.deleteMonitor(key, options),
       reactivate: (key, options) => this.reactivateMonitor(key, options),
+      start: (key, options) =>
+        options?.dryRun
+          ? this.submitMonitorBatch({
+              kind: 'reactivate',
+              scope: { kind: 'keys', monitorKeys: [key] },
+              dryRun: true,
+              idempotencyKey:
+                options.idempotencyKey ??
+                this.monitorJobIdempotencyKey(`start-${key}`),
+            })
+          : this.submitScalarMonitorLifecycle(key, 'start', options),
+      stop: (key, options) =>
+        options?.dryRun
+          ? this.submitMonitorBatch({
+              kind: 'deactivate',
+              scope: { kind: 'keys', monitorKeys: [key] },
+              dryRun: true,
+              idempotencyKey:
+                options.idempotencyKey ??
+                this.monitorJobIdempotencyKey(`stop-${key}`),
+            })
+          : this.submitScalarMonitorLifecycle(key, 'stop', options),
       audit: (options) => this.auditMonitors(options),
       repair: (options) => this.repairMonitors(options),
       health: (options) => this.readMonitorsHealth(options),
@@ -2392,6 +2607,15 @@ export class DeeplineClient {
         get: (operationId, options) =>
           this.getMonitorBatch(operationId, options),
       },
+      batches: {
+        sync: (batchId, definitions, options) =>
+          this.syncNamedMonitorBatch(batchId, definitions, options),
+        start: (batchId, options) =>
+          this.startNamedMonitorBatch(batchId, options),
+        stop: (batchId, options) =>
+          this.stopNamedMonitorBatch(batchId, options),
+        get: (batchId) => this.getNamedMonitorBatch(batchId),
+      },
       jobs: {
         get: (jobId) => this.getMonitorJob(jobId),
         logs: (jobId, options) => this.getMonitorJobLogs(jobId, options),
@@ -2412,6 +2636,10 @@ export class DeeplineClient {
           this.deactivateMonitorFleet(fleetId, options),
         reactivate: (fleetId, options) =>
           this.reactivateMonitorFleet(fleetId, options),
+        start: (fleetId, options) =>
+          this.reactivateMonitorFleet(fleetId, options),
+        stop: (fleetId, options) =>
+          this.deactivateMonitorFleet(fleetId, options),
         waitForConvergence: (fleetId, options) =>
           this.waitForMonitorFleetConvergence(fleetId, options),
       },
@@ -5978,7 +6206,11 @@ export class DeeplineClient {
     options?: MonitorsListOptions,
   ): Promise<MonitorsListResult> {
     const params = new URLSearchParams();
-    if (options?.status) params.set('status', options.status);
+    // `state` is the canonical filter. Keep sending the historical `status`
+    // parameter when callers use it so installed clients continue to work
+    // against older servers; never send both filters for one request.
+    if (options?.state) params.set('state', options.state);
+    else if (options?.status) params.set('status', options.status);
     if (options?.limit !== undefined)
       params.set('limit', String(options.limit));
     if (options?.cursor) params.set('cursor', options.cursor);
@@ -6165,6 +6397,118 @@ export class DeeplineClient {
     );
   }
 
+  private namedMonitorBatchPath(batchId: string): string {
+    return `/api/v2/monitors/batches/${encodeURIComponent(batchId)}`;
+  }
+
+  async syncNamedMonitorBatch(
+    batchId: string,
+    definitions: MonitorDefinition[],
+    options?: MonitorNamedBatchOptions,
+  ): Promise<MonitorJobResult> {
+    return this.http.request<MonitorJobResult>(
+      this.namedMonitorBatchPath(batchId),
+      {
+        method: 'PUT',
+        body: {
+          version: 1,
+          kind: 'batch',
+          monitors: definitions,
+          ...(options?.expectedGeneration === undefined
+            ? {}
+            : { expected_generation: options.expectedGeneration }),
+        },
+        headers: this.monitorJobHeaders(
+          `batch-sync-${batchId}`,
+          options?.idempotencyKey,
+        ),
+        maxRetries: 0,
+        exactUrlOnly: true,
+      },
+    );
+  }
+
+  async startNamedMonitorBatch(
+    batchId: string,
+    options?: Pick<MonitorNamedBatchOptions, 'idempotencyKey'>,
+  ): Promise<MonitorJobResult> {
+    return this.http.request<MonitorJobResult>(
+      `${this.namedMonitorBatchPath(batchId)}/start`,
+      {
+        method: 'POST',
+        body: {},
+        headers: this.monitorJobHeaders(
+          `batch-start-${batchId}`,
+          options?.idempotencyKey,
+        ),
+        maxRetries: 0,
+        exactUrlOnly: true,
+      },
+    );
+  }
+
+  async stopNamedMonitorBatch(
+    batchId: string,
+    options?: Pick<MonitorNamedBatchOptions, 'idempotencyKey'>,
+  ): Promise<MonitorJobResult> {
+    return this.http.request<MonitorJobResult>(
+      this.namedMonitorBatchPath(batchId),
+      {
+        method: 'DELETE',
+        body: {},
+        headers: this.monitorJobHeaders(
+          `batch-stop-${batchId}`,
+          options?.idempotencyKey,
+        ),
+        maxRetries: 0,
+        exactUrlOnly: true,
+      },
+    );
+  }
+
+  async getNamedMonitorBatch(batchId: string): Promise<MonitorJobResult> {
+    return this.http.request<MonitorJobResult>(
+      this.namedMonitorBatchPath(batchId),
+      { method: 'GET' },
+    );
+  }
+
+  async submitScalarMonitorLifecycle(
+    monitorKey: string,
+    action: 'start' | 'stop',
+    options?: Pick<MonitorLifecycleOptions, 'idempotencyKey'>,
+  ): Promise<MonitorJobResult> {
+    return this.http.request<MonitorJobResult>(
+      `/api/v2/monitors/deployed/${encodeURIComponent(monitorKey)}/${action}`,
+      {
+        method: 'POST',
+        body: {},
+        headers: this.monitorJobHeaders(
+          `${action}-${monitorKey}`,
+          options?.idempotencyKey,
+        ),
+        maxRetries: 0,
+        exactUrlOnly: true,
+      },
+    );
+  }
+
+  async syncScalarMonitor(
+    definition: MonitorDefinition,
+    options?: Pick<MonitorLifecycleOptions, 'idempotencyKey'>,
+  ): Promise<MonitorJobResult> {
+    return this.http.request<MonitorJobResult>('/api/v2/monitors/sync', {
+      method: 'POST',
+      body: definition,
+      headers: this.monitorJobHeaders(
+        `sync-${definition.key}`,
+        options?.idempotencyKey,
+      ),
+      maxRetries: 0,
+      exactUrlOnly: true,
+    });
+  }
+
   async getMonitorJob(jobId: string): Promise<MonitorJobResult> {
     return this.http.request<MonitorJobResult>(
       `/api/v2/monitors/jobs/${encodeURIComponent(jobId)}`,

package/dist/bundling-sources/sdk/src/index.ts

@@ -55,7 +55,12 @@
  */
 
 // ——— Client ———
-export { DeeplineClient } from './client.js';
+export {
+  DeeplineClient,
+  MONITOR_JOB_PHASES,
+  MONITOR_JOB_RECONCILIATION_STATES,
+  MONITOR_JOB_STATES,
+} from './client.js';
 export { CtxFetchHttpError } from './play.js';
 export { RunObserveTransportUnavailableError } from './runs/observe-transport.js';
 export type {
@@ -76,6 +81,9 @@ export type {
   MonitorsAvailableResult,
   MonitorsListOptions,
   MonitorsListResult,
+  MonitorState,
+  MonitorStateFilter,
+  LegacyMonitorStatusFilter,
   MonitorListEntry,
   MonitorCheckResult,
   MonitorDeployResult,
@@ -86,6 +94,9 @@ export type {
   MonitorUpdateResult,
   MonitorDeleteResult,
   MonitorReactivateResult,
+  MonitorJobPhase,
+  MonitorJobReconciliationState,
+  MonitorJobState,
   MonitorJobResult,
   MonitorJobDeployOptions,
   MonitorJobLogsOptions,

package/dist/bundling-sources/sdk/src/release.ts

@@ -200,7 +200,7 @@ export const SDK_RELEASE = {
   // getters keep their established compatibility behavior.
   // 0.3.1 deprecated the legacy `deepline enrich` command in favor of Plays.
   // 0.3.90 is the first deliberately versioned SDK release for API v3.
-  version: '0.3.115',
+  version: '0.3.117',
   updateSummary:
     'Play grep now returns concise results with the matched fields and terms. Automatic CLI updates are enabled by default; use `deepline settings autoupdate off` to opt out, `deepline settings autoupdate on` to re-enable updates, or `deepline settings autoupdate pin <version>` to hold an exact release.',
   packageCapabilities: {

package/dist/bundling-sources/shared_libs/monitors/billing/state.ts

@@ -4,6 +4,7 @@ import type {
   MonitorBillingPolicy,
 } from '@deepline/monitors/billing/types';
 import type { PublicMonitorCustomerChargeSummary } from '@deepline/monitors/billing/charges';
+import type { ProviderMonitorCustomerState } from '@deepline/monitors/provider-monitor-state';
 
 export type StoredMonitorBillingState = {
   state: MonitorBillingState;
@@ -31,13 +32,14 @@ const SUBSCRIPTION_RENEWAL_GUARD_MS = 24 * 60 * 60 * 1000;
 
 export type PublicMonitorBillingSummary = Pick<
   StoredMonitorBillingState,
-  | 'state'
   | 'lifecycle_charge_credits'
   | 'usage_charge_pending'
   | 'reactivation_required'
   | 'suspension_reason'
   | 'next_renewal_at'
 > & {
+  /** Customer projection; provider cleanup phases remain internal. */
+  state: ProviderMonitorCustomerState;
   create_charge?: PublicMonitorCustomerChargeSummary;
   reactivate_charge?: PublicMonitorCustomerChargeSummary;
 };
@@ -75,13 +77,17 @@ function readBillingState(value: unknown): MonitorBillingState {
   const state = readString(value);
   switch (state) {
     case 'active':
-    case 'preflight_denied':
     case 'billing_pending':
     case 'billing_suspended':
     case 'upstream_disable_pending':
     case 'upstream_disable_failed':
     case 'disabled':
       return state;
+    // Historical readers accepted this value, but no production writer ever
+    // produced it. Normalize a persisted legacy payload instead of retaining a
+    // dead state in the current billing state machine.
+    case 'preflight_denied':
+      return 'disabled';
     default:
       return 'billing_pending';
   }
@@ -160,15 +166,41 @@ export function parseStoredMonitorBillingState(
   };
 }
 
+/**
+ * Whether persisted billing truth forbids an automatic lifecycle revival.
+ *
+ * These states all represent an event-time billing suspension whose recovery
+ * is deliberately customer-driven. Provider cleanup may still be pending or
+ * may have failed, but neither a wallet top-up nor a policy sweep is authority
+ * to recreate the provider resource. Keep this predicate with the billing
+ * state decoder so every policy caller reads legacy/unknown payloads the same
+ * way.
+ */
+export function monitorBillingRequiresExplicitReactivation(
+  value: unknown,
+): boolean {
+  const state = parseStoredMonitorBillingState(value).state;
+  return (
+    state === 'billing_suspended' ||
+    state === 'upstream_disable_pending' ||
+    state === 'upstream_disable_failed'
+  );
+}
+
 export function publicMonitorBillingSummary(
   state: StoredMonitorBillingState,
+  customerState: ProviderMonitorCustomerState,
   charges?: {
     create_charge?: PublicMonitorCustomerChargeSummary;
     reactivate_charge?: PublicMonitorCustomerChargeSummary;
   },
 ): PublicMonitorBillingSummary {
+  const suspensionReason =
+    state.suspension_reason === 'billing_failure_upstream_disable_failed'
+      ? 'billing_failure'
+      : state.suspension_reason;
   return {
-    state: state.state,
+    state: customerState,
     lifecycle_charge_credits: state.lifecycle_charge_credits,
     usage_charge_pending: state.usage_charge_pending,
     reactivation_required: state.reactivation_required,
@@ -176,9 +208,7 @@ export function publicMonitorBillingSummary(
     ...(charges?.reactivate_charge
       ? { reactivate_charge: charges.reactivate_charge }
       : {}),
-    ...(state.suspension_reason
-      ? { suspension_reason: state.suspension_reason }
-      : {}),
+    ...(suspensionReason ? { suspension_reason: suspensionReason } : {}),
     ...(state.next_renewal_at !== undefined
       ? { next_renewal_at: state.next_renewal_at }
       : {}),

package/dist/bundling-sources/shared_libs/monitors/billing/types.ts

@@ -9,7 +9,6 @@ export type MonitorBillingPhase =
 
 export type MonitorBillingState =
   | 'active'
-  | 'preflight_denied'
   | 'billing_pending'
   | 'billing_suspended'
   | 'upstream_disable_pending'

package/dist/bundling-sources/shared_libs/monitors/deactivation-reasons.ts

@@ -1,3 +1,5 @@
+import { monitorBillingRequiresExplicitReactivation } from './billing/state';
+
 /**
  * Why a monitor is desired-inactive.
  *
@@ -60,8 +62,7 @@ export const MONITOR_DEACTIVATION_REASONS: readonly MonitorDeactivationReasonDef
     {
       id: 'billing_failure',
       owner: 'policy',
-      summary:
-        'Deactivated because monitor event billing was denied.',
+      summary: 'Deactivated because monitor event billing was denied.',
       resolution:
         'Resolve the billing restriction, then explicitly reactivate the monitors you want restored.',
     },
@@ -144,6 +145,7 @@ export function balanceAdmitsMonitors(balance: number | null): boolean {
 export type MonitorPolicyRow = {
   desired?: 'active' | 'inactive' | undefined;
   deactivationReason?: string | undefined;
+  billingState?: unknown;
 };
 
 export type MonitorPolicyDecision =
@@ -194,7 +196,8 @@ export function decideMonitorBalancePolicy(input: {
   if (
     input.balance !== null &&
     input.row.desired === 'inactive' &&
-    reason === 'insufficient_balance'
+    reason === 'insufficient_balance' &&
+    !monitorBillingRequiresExplicitReactivation(input.row.billingState)
   ) {
     return { kind: 'reactivate' };
   }