deepline 0.3.88 → 0.3.90

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

@@ -49,6 +49,12 @@ export const HOST_URL_ENV = 'DEEPLINE_HOST_URL';
 export const API_KEY_ENV = 'DEEPLINE_API_KEY';
 export const ACTIVE_ORG_ID_ENV = 'DEEPLINE_ACTIVE_ORG_ID';
 export const ACTIVE_ORG_NAME_ENV = 'DEEPLINE_ACTIVE_ORG_NAME';
+/**
+ * Comma-separated gated feature keys the server reported for the active
+ * workspace (`github-deploy`, …). Refreshed whenever credentials are saved;
+ * the CLI hides gated command groups whose key is absent.
+ */
+export const FEATURES_ENV = 'DEEPLINE_FEATURES';
 
 /** Production API base URL. */
 const PROD_URL = 'https://code.deepline.com';
@@ -83,8 +89,70 @@ const CLI_ENV_ALLOWED_KEYS = new Set([
   API_KEY_ENV,
   ACTIVE_ORG_ID_ENV,
   ACTIVE_ORG_NAME_ENV,
+  FEATURES_ENV,
 ]);
 
+/** Env line for a server-reported `features` list; absent input writes nothing. */
+export function featureEnvValues(data: {
+  features?: unknown;
+}): Record<string, string> {
+  if (!Array.isArray(data.features)) return {};
+  return {
+    [FEATURES_ENV]: data.features
+      .filter(
+        (key): key is string => typeof key === 'string' && key.trim() !== '',
+      )
+      .map((key) => key.trim())
+      .join(','),
+  };
+}
+
+/** The API key saved in the host's global credentials, or '' when none. */
+export function storedHostApiKey(baseUrl: string): string {
+  return loadCliEnv(normalizeBaseUrl(baseUrl) || baseUrl)[API_KEY_ENV] ?? '';
+}
+
+/** The raw features line saved with the host's global credentials, if any. */
+export function storedHostFeatures(baseUrl: string): string | undefined {
+  return loadCliEnv(normalizeBaseUrl(baseUrl) || baseUrl)[FEATURES_ENV];
+}
+
+/** Whether a stored features list names `feature`. */
+export function envHasFeature(env: EnvValues, feature: string): boolean {
+  return (env[FEATURES_ENV] ?? '')
+    .split(',')
+    .map((key) => key.trim())
+    .includes(feature);
+}
+
+/**
+ * Whether the active workspace was last seen with `feature` enabled. Reads
+ * the same credential sources, in the same order, as the API key: process
+ * env, the folder credentials pinned to the resolved host, then the host's
+ * global credentials. A host that cannot be resolved counts as no feature.
+ */
+export function cliFeatureEnabled(feature: string): boolean {
+  const processEnv = process.env as EnvValues;
+  if (envHasFeature(processEnv, feature)) return true;
+  // A process-env key wins for API calls, so only process-env features may
+  // describe it: a stored file's list belongs to a different credential.
+  if (processEnv[API_KEY_ENV]?.trim()) return false;
+  try {
+    const baseUrl = resolveBaseUrlOnly();
+    // The credential source that supplies the key also owns the features:
+    // a folder credential with no features line means "none", never "ask
+    // the global file", which may belong to a different workspace.
+    const projectEnv = loadProjectEnvCandidates().find(
+      ({ env }) =>
+        normalizeBaseUrl(env[HOST_URL_ENV] ?? '') === baseUrl &&
+        Boolean(env[API_KEY_ENV]),
+    );
+    return envHasFeature(projectEnv?.env ?? loadCliEnv(baseUrl), feature);
+  } catch {
+    return false;
+  }
+}
+
 export type CliCommandContext = {
   active_organization: {
     org_id: string;
@@ -402,6 +470,12 @@ function mergePersistedEnvValues(
   ) {
     delete merged[ACTIVE_ORG_ID_ENV];
     delete merged[ACTIVE_ORG_NAME_ENV];
+    delete merged[FEATURES_ENV];
+  }
+  // An explicit empty features list means "none": drop the stale line
+  // rather than keeping the previous workspace's features around.
+  if (values[FEATURES_ENV] === '') {
+    delete merged[FEATURES_ENV];
   }
   return merged;
 }
@@ -582,6 +656,9 @@ export function resolveConfig(options?: DeeplineClientOptions): ResolvedConfig {
     baseUrl,
     timeout: options?.timeout ?? DEFAULT_TIMEOUT,
     maxRetries: options?.maxRetries ?? DEFAULT_MAX_RETRIES,
+    // Pass through untouched: the transport owns case-insensitive merging so
+    // there is exactly one place that decides which header wins.
+    ...(options?.headers ? { headers: { ...options.headers } } : {}),
   };
 }
 

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

@@ -104,6 +104,31 @@ function normalizeRequestAbortError(
   return normalized;
 }
 
+/**
+ * Merge caller-supplied headers over everything the transport already derived
+ * from the environment, so an explicitly passed header always wins.
+ *
+ * HTTP header names are case-insensitive, so an existing header is removed by
+ * case-insensitive match before the normalized lowercase name is set. Without
+ * that, `Authorization` and `authorization` would both survive into the record
+ * and `new Headers(record)` would concatenate the two values.
+ */
+function applyExplicitHeaders(
+  headers: Record<string, string>,
+  explicit: Record<string, string> | undefined,
+): Record<string, string> {
+  if (!explicit) return headers;
+  for (const [rawName, value] of Object.entries(explicit)) {
+    const name = rawName.trim().toLowerCase();
+    if (!name) continue;
+    for (const existing of Object.keys(headers)) {
+      if (existing.toLowerCase() === name) delete headers[existing];
+    }
+    headers[name] = value;
+  }
+  return headers;
+}
+
 function isAbortLikeError(error: Error): boolean {
   const name = error.name.toLowerCase();
   const message = error.message.toLowerCase();
@@ -114,6 +139,17 @@ function isAbortLikeError(error: Error): boolean {
   );
 }
 
+function withErrorCause<T extends Error>(error: T, cause: unknown): T {
+  if (cause !== null && cause !== undefined) {
+    Object.defineProperty(error, 'cause', {
+      value: cause,
+      configurable: true,
+      writable: true,
+    });
+  }
+  return error;
+}
+
 function mapNetworkError(
   baseUrl: string,
   error: Error | null,
@@ -312,7 +348,11 @@ export class HttpClient {
       headers[COORDINATOR_INTERNAL_TOKEN_HEADER] =
         coordinatorInternalToken.trim();
     }
-    return headers;
+    // Explicit client-option headers (e.g. `deepline plays run --header`) are
+    // applied last so an operator can override an env-derived header without
+    // rewriting the environment. Authorization of these headers stays
+    // server-side.
+    return applyExplicitHeaders(headers, this.config.headers);
   }
 
   /**
@@ -540,37 +580,43 @@ export class HttpClient {
     );
     if (options?.toolId) {
       const code = mappedNetworkError.code;
-      throw new ToolExecutionError(
-        withCoworkNetworkHint(mappedNetworkError.message),
-        {
-          toolId: options.toolId,
-          provider: providerLabelFromToolId(options.toolId),
-          operation: options.toolId,
-          code,
-          origin: 'deepline',
-          category: 'network',
-          // A direct client timeout has ambiguous delivery. Fail closed unless
-          // the server returns the authoritative action delivery contract.
-          retryable: false,
-          statusCode: null,
-          requestId: null,
-          retryAfterMs: null,
-          networkKind:
-            code === 'NETWORK_TIMEOUT'
-              ? 'timeout'
-              : code === 'NETWORK_ABORTED'
-                ? 'unknown'
-                : 'unavailable',
-          networkScope: 'client_to_deepline',
-          details: mappedNetworkError.details,
-        },
+      throw withErrorCause(
+        new ToolExecutionError(
+          withCoworkNetworkHint(mappedNetworkError.message),
+          {
+            toolId: options.toolId,
+            provider: providerLabelFromToolId(options.toolId),
+            operation: options.toolId,
+            code,
+            origin: 'deepline',
+            category: 'network',
+            // A direct client timeout has ambiguous delivery. Fail closed unless
+            // the server returns the authoritative action delivery contract.
+            retryable: false,
+            statusCode: null,
+            requestId: null,
+            retryAfterMs: null,
+            networkKind:
+              code === 'NETWORK_TIMEOUT'
+                ? 'timeout'
+                : code === 'NETWORK_ABORTED'
+                  ? 'unknown'
+                  : 'unavailable',
+            networkScope: 'client_to_deepline',
+            details: mappedNetworkError.details,
+          },
+        ),
+        lastError,
       );
     }
-    throw new DeeplineError(
-      withCoworkNetworkHint(mappedNetworkError.message),
-      undefined,
-      mappedNetworkError.code,
-      mappedNetworkError.details,
+    throw withErrorCause(
+      new DeeplineError(
+        withCoworkNetworkHint(mappedNetworkError.message),
+        undefined,
+        mappedNetworkError.code,
+        mappedNetworkError.details,
+      ),
+      lastError,
     );
   }
 

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

@@ -94,11 +94,16 @@ export type {
   MonitorFleetWaitOptions,
   MonitorFleetResult,
   MonitorFleetsNamespace,
+  CreateNotificationGroupInput,
+  CreateNotificationGroupResult,
   IngestionStorageRepairResult,
   PlayStatus,
   PlaySheetRow,
   PlaySheetRowsResult,
   RunsListOptions,
+  RunsListPage,
+  PlaysListOptions,
+  PlaysListPage,
   RunsLogsOptions,
   RunsLogsResult,
   RunsNamespace,
@@ -232,6 +237,7 @@ export type {
   PublishPlayVersionRequest,
   PublishPlayVersionResult,
   StartPlayRunRequest,
+  PlayCostEstimate,
   PlayListItem,
   CustomerDbQueryResult,
   DeeplineToolCategory,
@@ -270,6 +276,10 @@ export type {
   PlayDatasetInput,
   PlayCallExecution,
   PlayCallOptions,
+  PlayAsyncCallOptions,
+  AsyncPlayRunRef,
+  PlayRunId,
+  PlayReferenceLike,
   PlayFetchResponse,
   RuntimeStepOptions,
   FetchOptions,

package/dist/bundling-sources/sdk/src/monitor-fleet-contract.ts

@@ -1,7 +1,7 @@
 /**
  * The fleet member ceiling, mirrored — deliberately a literal.
  *
- * The canonical declaration is shared_libs/monitors/monitor-fleet-limits.ts,
+ * The canonical declaration is packages/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

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

@@ -0,0 +1,25 @@
+/** Walk bounded cursor pages without reporting a partial result as complete. */
+export async function* iterateCursorPages<T>(
+  fetchPage: (cursor: string | null) => Promise<{
+    items: T[];
+    hasMore: boolean;
+    cursor: string | null;
+  }>,
+): AsyncGenerator<T[]> {
+  let cursor: string | null = null;
+  const seen = new Set<string>();
+  for (;;) {
+    const page = await fetchPage(cursor);
+    if (page.hasMore) {
+      if (!page.cursor || seen.has(page.cursor)) {
+        throw new Error(
+          'Pagination reported more results without an advancing cursor',
+        );
+      }
+      seen.add(page.cursor);
+    }
+    yield page.items;
+    if (!page.hasMore) return;
+    cursor = page.cursor;
+  }
+}

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

@@ -113,6 +113,9 @@ import type { ToolExecution } from './client.js';
 import type {
   DurableCallStaleAfterSeconds,
   PlayAuthoringBindings,
+  AsyncPlayRunRef as PlayAuthoringAsyncPlayRunRef,
+  PlayAuthoringAsyncCallOptions,
+  PlayRunId as PlayAuthoringRunId,
   PlayAuthoringCallExecution,
   PlayAuthoringCallOptions,
   PlayAuthoringColumnResolver,
@@ -676,7 +679,18 @@ export type PrebuiltPlayRef = {
   readonly name: string;
 };
 
-export type PlayReferenceLike = PlayAuthoringReferenceLike;
+export type PlayReferenceLike<
+  TInput extends Record<string, unknown> = Record<string, unknown>,
+> = PlayAuthoringReferenceLike<TInput>;
+
+/** Branded durable identity returned by ctx.runPlayAsync. */
+export type PlayRunId = PlayAuthoringRunId;
+
+/** Serializable reference to an independently scheduled Play Run. */
+export type AsyncPlayRunRef = PlayAuthoringAsyncPlayRunRef;
+
+/** Author intent for an independently scheduled child Run. */
+export type PlayAsyncCallOptions = PlayAuthoringAsyncCallOptions;
 
 export type {
   PlayDataset,

package/dist/bundling-sources/sdk/src/plays/bundle-play-file.ts

@@ -40,7 +40,7 @@ export type {
 
 export { extractDefinedPlayName } from '../../../shared_libs/plays/bundling/index.js';
 
-const PLAY_BUNDLE_CACHE_VERSION = 35;
+const PLAY_BUNDLE_CACHE_VERSION = 37;
 const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
 const SDK_PACKAGE_ROOT = resolve(MODULE_DIR, '..', '..');
 const SOURCE_REPO_ROOT = resolve(SDK_PACKAGE_ROOT, '..', '..');
@@ -84,12 +84,12 @@ let hasWarnedAboutNonDevelopmentBundling = false;
  * The SDK's job is to turn a local play file into a portable artifact using
  * only SDK/runtime sources. It must work for installed packages, source
  * checkouts, CI smoke jobs, and clean worktrees without app-generated files
- * such as `src/lib/generated/tool-typecheck-catalog.jsonl`.
+ * such as `packages/integrations/generated/tool-typecheck-catalog.jsonl`.
  *
  * Tool-aware validation belongs to the Deepline API after upload:
  * `compilePlayManifest` / server preflight runs the cloud typechecker inside
  * the app deployment, where the generated catalog is a normal build artifact.
- * Do not import `src/lib/plays/cloud-tool-typecheck` or any generated app
+ * Do not import `apps/deepline-api/src/lib/plays/cloud-tool-typecheck` or any generated app
  * catalog from this SDK adapter.
  */
 function warnAboutNonDevelopmentBundling(filePath: string): void {

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

@@ -23,12 +23,12 @@ import { CURRENT_PLAY_ARTIFACT_CONTRACT_VERSION } from '../../shared_libs/plays/
  * Everything else derives from these values:
  *
  *   - `packages/sdk/src/version.ts` re-exports `SDK_VERSION` and `SDK_API_CONTRACT`.
- *   - `src/lib/sdk/release-policy.ts` re-exports `SDK_RELEASE_POLICY`.
+ *   - `apps/deepline-api/src/lib/sdk/release-policy.ts` re-exports `SDK_RELEASE_POLICY`.
  *   - `packages/sdk/package.json` `version` is stamped from `SDK_RELEASE.version` by
  *     `scripts/sync-sdk-package-version.ts`, which runs as part of
  *     `bun run sdk:build`.
  *   - `contracts/sdk-api.manifest.json` is regenerated at build time from
- *     `src/lib/sdk/api-routes.ts` and the apiContract here; the matching
+ *     `apps/deepline-api/src/lib/sdk/api-routes.ts` and the apiContract here; the matching
  *     `contracts/sdk-api.manifest.hash` is an ignored local/CI audit artifact.
  *
  * Any drift between release source and derived release locations is a
@@ -199,21 +199,28 @@ export const SDK_RELEASE = {
   // available at toolResponse.rawV2 while toolResponse.raw and all declared
   // getters keep their established compatibility behavior.
   // 0.3.1 deprecated the legacy `deepline enrich` command in favor of Plays.
-  version: '0.3.88',
+  // 0.3.90 is the first deliberately versioned SDK release for API v3. Play
+  // grep hard-cuts to the single Convex full-text index; it does not retain a
+  // registry/scanner reader for any SDK/API major.
+  version: '0.3.90',
   updateSummary:
-    'Automatic CLI updates are now enabled by default. To opt out, run `deepline settings autoupdate off`; use `deepline settings autoupdate on` to re-enable updates or `deepline settings autoupdate pin <version>` to hold an exact release. This release also adds raw-v2 tool responses at toolResponse.rawV2 while preserving existing toolResponse.raw and declared getters.',
+    'Play grep now uses one source-only Convex full-text index. It no longer scans the registry, pages through the complete indexed match set, and rejects retired grep modes. 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: {
     updatePreferences: 1,
   },
   contracts: {
     api: {
       name: 'sdk-http-api',
-      // API v2 is append-only. A breaking public request/response change needs
-      // v3 and an explicit v2 support-window decision, never a patch release.
-      currentMajor: 2,
-      supportedMajors: [2],
-      // Accepted only to bridge SDKs released before X-Deepline-API-Major.
+      // API v3 hard-cuts Play grep to the canonical Convex index. API v2 stays
+      // admitted for the explicit SDK support window, but it selects neither a
+      // registry scanner nor another grep reader: every accepted grep request
+      // uses the same indexed query and retired flags fail at the API boundary.
+      currentMajor: 3,
+      supportedMajors: [3, 2],
+      // The first wire id is emitted by the current SDK. Remaining ids are
+      // accepted only while the API v2 support window is open.
       legacyWireIds: [
+        '2026-09-play-grep-convex-index-hard-cutover',
         '2026-07-admin-cli-local-cutover',
         '2026-07-native-monitor-launch-hard-cutover',
       ],

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

@@ -19,6 +19,19 @@ import type {
   PlayBootstrapStageKind,
   PlayBootstrapTemplate,
 } from '../../shared_libs/plays/bootstrap-routes';
+import type {
+  EffectiveProductNotificationConfiguration,
+  ProductNotificationConfigurationChange,
+  ProductNotificationDefaultPolicy,
+} from '../../shared_libs/product-notifications/configuration';
+import type { ProductNotificationTypeCatalogItem } from '../../shared_libs/product-notifications/catalog';
+
+export type {
+  EffectiveProductNotificationConfiguration,
+  ProductNotificationConfigurationChange,
+  ProductNotificationDefaultPolicy,
+  ProductNotificationTypeCatalogItem,
+};
 
 // ——————————————————————————————————————————————————————————
 // Config
@@ -56,6 +69,17 @@ export 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>;
 }
 
 /**
@@ -72,6 +96,12 @@ export 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. */
@@ -795,8 +825,9 @@ export 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;
   /**
@@ -808,14 +839,26 @@ export 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. */
 export 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;
@@ -824,6 +867,32 @@ export interface ChildRunSummary {
   finishedAt?: number | null;
 }
 
+export interface AsyncChildRunStatusCounts {
+  total: number;
+  queued: number;
+  active: number;
+  waiting: number;
+  succeeded: number;
+  failed: number;
+  cancelled: number;
+  unknown: number;
+}
+
+export interface AsyncChildRunLaunchProjection {
+  launchKey: string | null;
+  playName: string | null;
+  counts: AsyncChildRunStatusCounts;
+  children: ChildRunSummary[];
+}
+
+export 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.
@@ -1114,6 +1183,28 @@ export interface PlayDefinitionDetail {
   currentPublishedVersion?: number | null;
 }
 
+export 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;
+    };
+
 export interface PlayListItem {
   playKey?: string;
   reference?: string;
@@ -1143,6 +1234,7 @@ export interface PlayListItem {
   liveRevision?: PlayRevisionSummary | null;
   aliases?: string[];
   triggerStatus?: PlayTriggerStatus;
+  costEstimate?: PlayCostEstimate;
 }
 
 /** Additive live trigger state shared by list, get, and describe. */
@@ -1189,6 +1281,16 @@ export interface ProductNotification {
   lastErrorMessage?: string;
 }
 
+export interface ProductNotificationConfigurationResponse {
+  configuration: EffectiveProductNotificationConfiguration;
+  catalog: readonly ProductNotificationTypeCatalogItem[];
+  slackConnection: {
+    connected: boolean;
+    status: string;
+    connectionId?: string;
+  };
+}
+
 export interface PlayDescription {
   name: string;
   /** Stable registry key. Same value `plays list` reports for this play. */

package/dist/bundling-sources/shared_libs/integration-contracts/AGENTS.md

@@ -0,0 +1,9 @@
+# Integration Contracts
+
+This package is the only integration-owned boundary shared with public clients.
+
+- Put a value here only when both `packages/integrations` and a public client such as `packages/sdk` must interpret it identically.
+- Keep contracts pure and dependency-light. Do not import provider runtimes, generated catalogs, credentials, billing implementations, action schemas, or application code.
+- Provider implementations and server-only policy remain in `packages/integrations`.
+- The public SDK bundles this package; it must not acquire a runtime dependency on a private workspace package.
+- Prefer a server-driven protocol over adding provider-specific client knowledge when compatibility permits it.

package/dist/bundling-sources/shared_libs/integration-contracts/README.md

@@ -0,0 +1,3 @@
+# `@deepline/integration-contracts`
+
+Pure contracts that must be interpreted identically by integration runtimes and public clients. Server-only integration code belongs in `packages/integrations`; SDK-only behavior belongs in `packages/sdk`.

package/dist/bundling-sources/shared_libs/integration-contracts/index.ts

@@ -0,0 +1,2 @@
+export * from './bettercontact/execution-policy';
+export * from './theirstack/execution-policy';