deepline 0.3.0 → 0.3.2

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

@@ -4656,6 +4656,12 @@ export class DeeplineClient {
       {
         method: 'POST',
         body: definition,
+        // A provider can reject a create with a 429 after Deepline has begun
+        // the lifecycle request. Do not replay a mutation or hide the server's
+        // monitor-specific recovery guidance behind a generic transport retry.
+        maxRetries: 0,
+        exactUrlOnly: true,
+        preserveRateLimitResponse: true,
       },
     );
     if (definition.tool !== 'deepline.analytics') return deployed;

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

@@ -70,6 +70,12 @@ interface RequestOptions {
   maxRetries?: number;
   /** Disable localhost/127.0.0.1 failover for non-idempotent requests. */
   exactUrlOnly?: boolean;
+  /**
+   * Return a server-owned 429 envelope as a DeeplineError instead of replacing
+   * it with the transport's generic RateLimitError. Lifecycle mutations use
+   * this when their response explains whether the upstream change applied.
+   */
+  preserveRateLimitResponse?: boolean;
   /** Enables endpoint-specific structured tool failure mapping. */
   toolId?: string;
 }
@@ -419,6 +425,17 @@ export class HttpClient {
           }
 
           if (response.status === 429) {
+            if (
+              options?.preserveRateLimitResponse &&
+              isMonitorRateLimitEnvelope(parsed)
+            ) {
+              throw new DeeplineError(
+                apiErrorMessage(parsed, response.status),
+                response.status,
+                apiErrorCodeFromResponse(parsed),
+                { response: parsed },
+              );
+            }
             const retryAfter = parseRetryAfter(response);
             lastError = new RateLimitError(retryAfter);
             if (attempt < maxRetries) {
@@ -779,6 +796,21 @@ function isProviderOriginatedHttpError(parsed: unknown): boolean {
   return failureOrigin === 'provider' || code === 'UPSTREAM_BLOCKED';
 }
 
+/**
+ * A monitor deployment may receive a safe, actionable 429 from Deepline after
+ * an upstream lifecycle attempt. Do not treat a CDN/WAF 429 as that envelope:
+ * it can be arbitrary HTML or text and must retain normal RateLimitError
+ * behavior.
+ */
+function isMonitorRateLimitEnvelope(parsed: unknown): boolean {
+  const response = asRecord(parsed);
+  const error = asRecord(response?.error);
+  return (
+    error?.code === 'monitor_upstream_rate_limited' &&
+    typeof error.message === 'string'
+  );
+}
+
 function apiErrorCodeFromResponse(parsed: unknown): string {
   const response = asRecord(parsed);
   const error = asRecord(response?.error);

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

@@ -2,6 +2,7 @@ import { tmpdir } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { existsSync } from 'node:fs';
+import { realpath } from 'node:fs/promises';
 import {
   bundlePlayFile as bundlePlayFileCore,
   type BundlePlayFileOptions,
@@ -145,10 +146,23 @@ export async function bundlePlayFile(
   filePath: string,
   options: BundlePlayFileOptions = {},
 ): Promise<BundledPlayFileResult> {
+  // The SDK sends this graph to a remote checker/runtime. Its file identities
+  // therefore must describe the authoring workspace, rather than the local
+  // machine paths used while building it. This is especially important on
+  // Windows: a raw `C:\\...` key cannot be reconciled beneath `/var/task`.
+  // Match the bundler's physical-path normalization. On macOS, for example,
+  // os.tmpdir() can report /var while the source graph resolves /private/var.
+  const localWorkspaceRoot = dirname(resolve(filePath));
+  const sourceIdentityRoot = await realpath(localWorkspaceRoot).catch(
+    () => localWorkspaceRoot,
+  );
   const result = await bundlePlayFileCore(filePath, {
     target: options.target ?? defaultPlayBundleTarget(),
     exportName: options.exportName,
-    adapter: createSdkPlayBundlingAdapter(),
+    adapter: {
+      ...createSdkPlayBundlingAdapter(),
+      sourceIdentityRoot,
+    },
   });
   if (result.success)
     validatePlaySourceFilesHaveNoInlineSecrets(result.sourceFiles);

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

@@ -192,7 +192,7 @@ export const SDK_RELEASE = {
   // 0.3.0 introduces raw-v2: complete scrubbed provider responses are
   // available at toolResponse.rawV2 while toolResponse.raw and all declared
   // getters keep their established compatibility behavior.
-  version: '0.3.0',
+  version: '0.3.2',
   updateSummary:
     'New raw-v2 tool responses preserve complete scrubbed provider envelopes at toolResponse.rawV2, including JSON:API included resources, links, cursors, and totals. Existing toolResponse.raw and declared getters keep working unchanged.',
   contracts: {

package/dist/bundling-sources/shared_libs/play-runtime/runner-backends/backends/daytona-lifecycle.ts

@@ -51,6 +51,7 @@ export type AcquiredDaytonaSandbox = {
   daytonaOrganizationId: string;
   billingStartedAt: number;
   billingEndedAt?: number;
+  sandboxCapacityLeaseId?: string;
 };
 
 export type OneShotDaytonaSandboxLifecycle = {
@@ -118,6 +119,7 @@ type DaytonaCreateResult = {
   sandbox: DaytonaSandbox;
   attempt: number;
   attemptElapsedMs: number;
+  sandboxCapacityLeaseId?: string;
 };
 
 function daytonaCreateErrorClass(
@@ -133,6 +135,8 @@ function daytonaCreateErrorClass(
 async function rejectAcquiredSandbox(
   sandbox: DaytonaSandbox,
   reason: string,
+  reservation?: { leaseId: string },
+  releaseSandboxCapacity?: (leaseId: string) => Promise<void>,
 ): Promise<never> {
   try {
     await sandbox.delete(30);
@@ -143,6 +147,9 @@ async function rejectAcquiredSandbox(
       { cause: error },
     );
   }
+  if (reservation) {
+    await releaseSandboxCapacity?.(reservation.leaseId);
+  }
   throw new Error(reason);
 }
 
@@ -350,6 +357,8 @@ async function createRetriedOneShotDaytonaSandbox(input: {
   context: DaytonaExecutionContext;
   emitStage: DaytonaStageEmitter;
   observeCreateCall?: DaytonaCreateCallObserver;
+  reserveSandboxCapacity?: () => Promise<{ leaseId: string }>;
+  releaseSandboxCapacity?: (leaseId: string) => Promise<void>;
   nextProviderAttempt: () => number;
   startedAt: number;
 }): Promise<DaytonaCreateResult> {
@@ -372,6 +381,7 @@ async function createRetriedOneShotDaytonaSandbox(input: {
       occurredAtMs: attemptStartedAt,
       providerAttempt: attempt,
     });
+    const reservation = await input.reserveSandboxCapacity?.();
     let sandbox: DaytonaSandbox;
     try {
       sandbox = await createOneShotDaytonaSandbox({
@@ -381,6 +391,12 @@ async function createRetriedOneShotDaytonaSandbox(input: {
         sandboxName,
       });
     } catch (error) {
+      // A normal rejected create has no durable provider resource. A timeout
+      // can be ambiguous, so retain its lease until the crash TTL rather than
+      // admitting another sandbox against an unknown provider outcome.
+      if (reservation && !isDaytonaSandboxStartTimeout(String(error))) {
+        await input.releaseSandboxCapacity?.(reservation.leaseId);
+      }
       await input.observeCreateCall?.({
         type: 'daytona_create_call_failed',
         occurredAtMs: Date.now(),
@@ -407,6 +423,13 @@ async function createRetriedOneShotDaytonaSandbox(input: {
           sandboxName,
         });
         if (deleted) {
+          // The provider-confirmed reconciliation means this reservation can
+          // no longer represent a live sandbox. Release before returning the
+          // acquisition-unavailable result so Modal fallback is not blocked
+          // behind the unbound crash TTL.
+          if (reservation) {
+            await input.releaseSandboxCapacity?.(reservation.leaseId);
+          }
           throw new DaytonaSandboxAcquisitionUnavailableError(
             'daytona_sandbox_start_timeout',
             `${message} Timed-out Daytona sandbox was reconciled and deleted before fallback.`,
@@ -448,6 +471,7 @@ async function createRetriedOneShotDaytonaSandbox(input: {
       sandbox,
       attempt,
       attemptElapsedMs: acquiredAt - attemptStartedAt,
+      ...(reservation ? { sandboxCapacityLeaseId: reservation.leaseId } : {}),
     };
   }
   const message = `Daytona sandbox create failed across ${errors.length} bounded attempts: ${errors.join('; ')}`;
@@ -468,6 +492,8 @@ async function acquireOneShotDaytonaSandbox(input: {
   context: DaytonaExecutionContext;
   emitStage: DaytonaStageEmitter;
   observeCreateCall?: DaytonaCreateCallObserver;
+  reserveSandboxCapacity?: () => Promise<{ leaseId: string }>;
+  releaseSandboxCapacity?: (leaseId: string) => Promise<void>;
   nextProviderAttempt: () => number;
   startedAt: number;
 }): Promise<AcquiredDaytonaSandbox> {
@@ -493,6 +519,10 @@ async function acquireOneShotDaytonaSandbox(input: {
     await rejectAcquiredSandbox(
       result.sandbox,
       `Daytona sandbox resource boundary mismatch: expected cpu=${limits.cpu} memoryGiB=${limits.memoryGiB} diskGiB=${limits.diskGiB} gpu=${DAYTONA_SANDBOX_GPU}, granted cpu=${granted.cpu} memoryGiB=${granted.memoryGiB} diskGiB=${granted.diskGiB} gpu=${granted.gpu}`,
+      result.sandboxCapacityLeaseId
+        ? { leaseId: result.sandboxCapacityLeaseId }
+        : undefined,
+      input.releaseSandboxCapacity,
     );
   }
   const configuredOrganizationId =
@@ -506,6 +536,10 @@ async function acquireOneShotDaytonaSandbox(input: {
     await rejectAcquiredSandbox(
       result.sandbox,
       'Daytona sandbox organization routing mismatch. Refusing to run customer code in a sandbox whose observed organization differs from the configured organization.',
+      result.sandboxCapacityLeaseId
+        ? { leaseId: result.sandboxCapacityLeaseId }
+        : undefined,
+      input.releaseSandboxCapacity,
     );
   }
   let lookupOrganizationId: string | null = null;
@@ -528,6 +562,10 @@ async function acquireOneShotDaytonaSandbox(input: {
     return await rejectAcquiredSandbox(
       result.sandbox,
       'Daytona sandbox organization routing identity is missing. Refusing to run customer code without a durable cleanup routing domain.',
+      result.sandboxCapacityLeaseId
+        ? { leaseId: result.sandboxCapacityLeaseId }
+        : undefined,
+      input.releaseSandboxCapacity,
     );
   }
   const billingStartedAt = Date.now();
@@ -541,7 +579,14 @@ async function acquireOneShotDaytonaSandbox(input: {
     memoryGiB: granted.memoryGiB,
     diskGiB: granted.diskGiB,
   });
-  return { sandbox, daytonaOrganizationId, billingStartedAt };
+  return {
+    sandbox,
+    daytonaOrganizationId,
+    billingStartedAt,
+    ...(result.sandboxCapacityLeaseId
+      ? { sandboxCapacityLeaseId: result.sandboxCapacityLeaseId }
+      : {}),
+  };
 }
 
 export function createOneShotDaytonaSandboxLifecycle(input: {
@@ -549,6 +594,8 @@ export function createOneShotDaytonaSandboxLifecycle(input: {
   context: DaytonaExecutionContext;
   emitStage: DaytonaStageEmitter;
   observeCreateCall?: DaytonaCreateCallObserver;
+  reserveSandboxCapacity?: () => Promise<{ leaseId: string }>;
+  releaseSandboxCapacity?: (leaseId: string) => Promise<void>;
   startedAt?: number;
 }): OneShotDaytonaSandboxLifecycle {
   const orgId = validateDaytonaExecutionContext(input.context);
@@ -564,6 +611,8 @@ export function createOneShotDaytonaSandboxLifecycle(input: {
       context: input.context,
       emitStage: input.emitStage,
       observeCreateCall: input.observeCreateCall,
+      reserveSandboxCapacity: input.reserveSandboxCapacity,
+      releaseSandboxCapacity: input.releaseSandboxCapacity,
       nextProviderAttempt: () => {
         providerAttempt += 1;
         return providerAttempt;
@@ -594,6 +643,13 @@ export function createOneShotDaytonaSandboxLifecycle(input: {
       try {
         const acquired = await latestAcquiredSandboxPromise;
         await acquired.sandbox.delete(30);
+        // `dispose` has provider-confirmed that the sandbox is gone. This is
+        // normally the narrow cancellation window before the scheduler has
+        // durably recorded the resource, so no cleanup job will release an
+        // unbound lease on our behalf.
+        if (acquired.sandboxCapacityLeaseId) {
+          await input.releaseSandboxCapacity?.(acquired.sandboxCapacityLeaseId);
+        }
       } catch (error) {
         console.warn('[play-runner.daytona.dispose_failed_before_acquire]', {
           error: error instanceof Error ? error.message : String(error),

package/dist/bundling-sources/shared_libs/play-runtime/runner-backends/backends/daytona.ts

@@ -5,7 +5,10 @@ import type {
   PlayRunnerPreparedExecution,
   PlayRunnerPrepareInput,
 } from '../types';
-import { RuntimeResourceFenceLostError } from '../types';
+import {
+  isRuntimeSandboxCapacityLimitError,
+  RuntimeResourceFenceLostError,
+} from '../types';
 import { buildPlayRunnerBundle } from '../bundle';
 import { findPlayRunnerResult, parsePlayRunnerEvents } from '../runner-events';
 import type {
@@ -26,6 +29,7 @@ import {
   DaytonaSandboxAcquisitionUnavailableError,
   createDaytonaSandboxCleanupManager,
   createOneShotDaytonaSandboxLifecycle,
+  type AcquiredDaytonaSandbox,
   type DaytonaClient,
   type DaytonaExecutionContext,
   type DaytonaSandbox,
@@ -945,6 +949,10 @@ function prepareDaytonaExecution(
     emitStage: (stage, extra) =>
       emitDaytonaStage(callbacks, input.context, stage, extra),
     observeCreateCall: callbacks?.onRuntimeLifecycleEvent,
+    reserveSandboxCapacity: callbacks?.reserveSandboxCapacity
+      ? () => callbacks.reserveSandboxCapacity!('daytona')
+      : undefined,
+    releaseSandboxCapacity: callbacks?.releaseSandboxCapacity,
   });
   return {
     kind: 'daytona',
@@ -1055,22 +1063,12 @@ export const daytonaPlayRunnerBackend: PlayRunnerBackend = {
     };
     let cancellationRequested = false;
     let cancellationCleanupStarted = false;
-    let activeAcquiredResource: {
-      sandbox: DaytonaSandbox;
-      daytonaOrganizationId: string;
-      billingStartedAt: number;
-      billingEndedAt?: number;
-    } | null = null;
+    let activeAcquiredResource: AcquiredDaytonaSandbox | null = null;
     const uploadDeadlineBreaches: DaytonaUploadAttemptTiming[] = [];
     const reportedSandboxIds = new Set<string>();
     const reportedSandboxEndTimes = new Map<string, number | null>();
     const runtimeResourceReportErrors = new Set<unknown>();
-    const reportRuntimeResource = async (acquired: {
-      sandbox: DaytonaSandbox;
-      daytonaOrganizationId: string;
-      billingStartedAt: number;
-      billingEndedAt?: number;
-    }) => {
+    const reportRuntimeResource = async (acquired: AcquiredDaytonaSandbox) => {
       const sandbox = acquired.sandbox;
       const billingEndedAt = acquired.billingEndedAt ?? null;
       if (
@@ -1101,6 +1099,9 @@ export const daytonaPlayRunnerBackend: PlayRunnerBackend = {
           cpu: typeof sandbox.cpu === 'number' ? sandbox.cpu : null,
           memoryGiB: typeof sandbox.memory === 'number' ? sandbox.memory : null,
           diskGiB: typeof sandbox.disk === 'number' ? sandbox.disk : null,
+          ...(acquired.sandboxCapacityLeaseId
+            ? { sandboxCapacityLeaseId: acquired.sandboxCapacityLeaseId }
+            : {}),
         });
       } catch (error) {
         runtimeResourceReportErrors.add(error);
@@ -1109,12 +1110,9 @@ export const daytonaPlayRunnerBackend: PlayRunnerBackend = {
       reportedSandboxIds.add(sandbox.id);
       reportedSandboxEndTimes.set(sandbox.id, billingEndedAt);
     };
-    const reportRetiringRuntimeResource = async (acquired: {
-      sandbox: DaytonaSandbox;
-      daytonaOrganizationId: string;
-      billingStartedAt: number;
-      billingEndedAt?: number;
-    }) => {
+    const reportRetiringRuntimeResource = async (
+      acquired: AcquiredDaytonaSandbox,
+    ) => {
       try {
         await reportRuntimeResource(acquired);
       } catch (error) {
@@ -1429,6 +1427,9 @@ export const daytonaPlayRunnerBackend: PlayRunnerBackend = {
         }
         throw error;
       }
+      if (isRuntimeSandboxCapacityLimitError(error)) {
+        throw error;
+      }
       if (error instanceof DaytonaSandboxAcquisitionUnavailableError) {
         throw error;
       }

package/dist/bundling-sources/shared_libs/play-runtime/runner-backends/backends/modal.ts

@@ -1,6 +1,9 @@
 import type { ModalClient } from 'modal';
 import type { PlayRunnerBackend, PlayRunnerCallbacks } from '../types';
-import { RuntimeResourceFenceLostError } from '../types';
+import {
+  isRuntimeSandboxCapacityLimitError,
+  RuntimeResourceFenceLostError,
+} from '../types';
 import { buildPlayRunnerBundle } from '../bundle';
 import type {
   PlayRunnerExecutionConfig,
@@ -23,6 +26,7 @@ import { stageRunnerPayload } from './daytona-payload-transport';
 import { captureDetachedDaytonaRunnerReadinessBaseline } from './daytona-session-execution';
 
 const MODAL_RUNNER_READY_TIMEOUT_MS = 30_000;
+const MODAL_CAPACITY_RELEASE_RETRY_DELAYS_MS = [0, 100, 500, 2_000] as const;
 type ModalSandbox = Awaited<ReturnType<ModalClient['sandboxes']['create']>>;
 
 export function modalSandboxLifetimeMs(
@@ -99,13 +103,38 @@ async function confirmDetachedModalRunnerReady(input: {
   );
 }
 
-async function terminateModalSandbox(sandbox: ModalSandbox): Promise<void> {
-  await sandbox.terminate().catch((error) => {
+async function terminateModalSandbox(sandbox: ModalSandbox): Promise<boolean> {
+  try {
+    // The default terminate call only acknowledges the request. Capacity may
+    // be released only after Modal confirms the sandbox itself has stopped.
+    await sandbox.terminate({ wait: true });
+    return true;
+  } catch (error) {
     console.warn('[play-runner.modal.terminate_failed]', {
       sandboxId: sandbox.sandboxId,
       error: error instanceof Error ? error.message : String(error),
     });
-  });
+    return false;
+  }
+}
+
+async function releaseModalSandboxCapacityAfterConfirmedTermination(input: {
+  leaseId: string;
+  release: NonNullable<PlayRunnerCallbacks['releaseSandboxCapacity']>;
+}): Promise<void> {
+  let lastError: unknown;
+  for (const delayMs of MODAL_CAPACITY_RELEASE_RETRY_DELAYS_MS) {
+    if (delayMs > 0) {
+      await new Promise<void>((resolve) => setTimeout(resolve, delayMs));
+    }
+    try {
+      await input.release(input.leaseId);
+      return;
+    } catch (error) {
+      lastError = error;
+    }
+  }
+  throw lastError;
 }
 
 export const modalPlayRunnerBackend: PlayRunnerBackend = {
@@ -139,24 +168,35 @@ export const modalPlayRunnerBackend: PlayRunnerBackend = {
         createIfMissing: true,
       });
       const image = modalConfig.client.images.fromRegistry(modalConfig.image);
-      const sandbox = await modalConfig.client.sandboxes.create(app, image, {
-        cpu: MODAL_SANDBOX_CPU_CORES,
-        cpuLimit: MODAL_SANDBOX_CPU_CORES,
-        memoryMiB: MODAL_SANDBOX_MEMORY_MIB,
-        memoryLimitMiB: MODAL_SANDBOX_MEMORY_MIB,
-        timeoutMs: modalSandboxLifetimeMs(modalConfig.limits),
-        idleTimeoutMs: modalSandboxLifetimeMs(modalConfig.limits),
-        workdir: modalConfig.workdir,
-        tags: {
-          source: 'deepline-play-runner',
-          orgId: config.context.orgId ?? 'unknown',
-          workflowId: config.context.workflowId ?? 'unknown',
-          runId: config.context.runId ?? 'unknown',
-        },
-        ...(modalConfig.outboundCidrAllowlist
-          ? { outboundCidrAllowlist: modalConfig.outboundCidrAllowlist }
-          : {}),
-      });
+      const capacityReservation =
+        await callbacks?.reserveSandboxCapacity?.('modal');
+      const sandbox = await modalConfig.client.sandboxes
+        .create(app, image, {
+          cpu: MODAL_SANDBOX_CPU_CORES,
+          cpuLimit: MODAL_SANDBOX_CPU_CORES,
+          memoryMiB: MODAL_SANDBOX_MEMORY_MIB,
+          memoryLimitMiB: MODAL_SANDBOX_MEMORY_MIB,
+          timeoutMs: modalSandboxLifetimeMs(modalConfig.limits),
+          idleTimeoutMs: modalSandboxLifetimeMs(modalConfig.limits),
+          workdir: modalConfig.workdir,
+          tags: {
+            source: 'deepline-play-runner',
+            orgId: config.context.orgId ?? 'unknown',
+            workflowId: config.context.workflowId ?? 'unknown',
+            runId: config.context.runId ?? 'unknown',
+          },
+          ...(modalConfig.outboundCidrAllowlist
+            ? { outboundCidrAllowlist: modalConfig.outboundCidrAllowlist }
+            : {}),
+        })
+        .catch(async (error) => {
+          if (capacityReservation) {
+            await callbacks?.releaseSandboxCapacity?.(
+              capacityReservation.leaseId,
+            );
+          }
+          throw error;
+        });
       const billingStartedAt = Date.now();
       runtimeTiming.modalCreateMs = billingStartedAt - startedAt;
       emitModalStage(config.context, 'create:done', {
@@ -164,6 +204,7 @@ export const modalPlayRunnerBackend: PlayRunnerBackend = {
         elapsedMs: runtimeTiming.modalCreateMs,
       });
       let detached = false;
+      let setupError: unknown;
       let cancelExecution!: (error: Error) => void;
       const cancellationPromise = new Promise<never>((_resolve, reject) => {
         cancelExecution = reject;
@@ -192,6 +233,9 @@ export const modalPlayRunnerBackend: PlayRunnerBackend = {
             cpu: MODAL_SANDBOX_CPU_CORES,
             memoryGiB: MODAL_SANDBOX_MEMORY_MIB / 1024,
             diskGiB: 0,
+            ...(capacityReservation
+              ? { sandboxCapacityLeaseId: capacityReservation.leaseId }
+              : {}),
           });
         } catch (error) {
           runtimeResourceRegistrationError = error;
@@ -290,14 +334,45 @@ export const modalPlayRunnerBackend: PlayRunnerBackend = {
           tableNamespace: null,
           runtimeTiming,
         };
+      } catch (error) {
+        setupError = error;
+        throw error;
       } finally {
         callbacks?.cancellationSignal?.removeEventListener('abort', onCancel);
-        if (!detached) await terminateModalSandbox(sandbox);
+        if (!detached && (await terminateModalSandbox(sandbox))) {
+          // This branch synchronously confirms that the just-created resource
+          // is gone. Do not keep its admission lease until the cleanup loop
+          // sees a resource that no longer exists.
+          if (capacityReservation && callbacks?.releaseSandboxCapacity) {
+            try {
+              await releaseModalSandboxCapacityAfterConfirmedTermination({
+                leaseId: capacityReservation.leaseId,
+                release: callbacks.releaseSandboxCapacity,
+              });
+            } catch (releaseError) {
+              // The scheduler fence is the primary correctness signal. Keep
+              // it intact if its best-effort early capacity release is
+              // transiently unavailable; durable cleanup will retry release.
+              if (setupError) {
+                console.error('[play-runner.modal.capacity_release_failed]', {
+                  sandboxId: sandbox.sandboxId,
+                  error:
+                    releaseError instanceof Error
+                      ? releaseError.message
+                      : String(releaseError),
+                });
+              } else {
+                throw releaseError;
+              }
+            }
+          }
+        }
       }
     } catch (error) {
       if (
         error === runtimeResourceRegistrationError ||
-        error instanceof RuntimeResourceFenceLostError
+        error instanceof RuntimeResourceFenceLostError ||
+        isRuntimeSandboxCapacityLimitError(error)
       ) {
         throw error;
       }
@@ -335,7 +410,7 @@ export async function deleteModalSandboxById(input: {
       appId: expectedAppId,
     })) {
       if (sandbox.sandboxId !== input.sandboxId) continue;
-      await sandbox.terminate();
+      await sandbox.terminate({ wait: true });
       return { kind: 'deleted', appId: expectedAppId };
     }
     // Cleanup means ensure absent. An exact app-scoped inventory proving the

package/dist/bundling-sources/shared_libs/play-runtime/runner-backends/types.ts

@@ -28,6 +28,8 @@ export type PlayRunnerRuntimeResource = {
   cpu?: number | null;
   memoryGiB?: number | null;
   diskGiB?: number | null;
+  /** Scheduler-only soft-capacity reservation made before provider create. */
+  sandboxCapacityLeaseId?: string;
 };
 
 export type RuntimeResourceTerminalReason =
@@ -64,6 +66,23 @@ export class RuntimeResourceFenceLostError extends Error {
   }
 }
 
+/**
+ * A scheduler-owned admission result crosses the provider-backend boundary.
+ * Keep it typed by name here so the shared backend can rethrow it without an
+ * import from the app-owned scheduler implementation.
+ */
+export const RUNTIME_SANDBOX_CAPACITY_LIMIT_ERROR_NAME =
+  'RuntimeSandboxCapacityLimitError';
+
+export function isRuntimeSandboxCapacityLimitError(
+  error: unknown,
+): error is Error {
+  return (
+    error instanceof Error &&
+    error.name === RUNTIME_SANDBOX_CAPACITY_LIMIT_ERROR_NAME
+  );
+}
+
 export interface PlayRunnerCallbacks {
   onLog?: (event: PlayRunnerLogEvent) => void;
   onCheckpoint?: (checkpoint: PlayCheckpoint) => void;
@@ -72,6 +91,12 @@ export interface PlayRunnerCallbacks {
   onRuntimeResourceAcquired?: (
     resource: PlayRunnerRuntimeResource,
   ) => void | Promise<void>;
+  /** Reserve one physical-sandbox slot immediately before a provider create. */
+  reserveSandboxCapacity?: (
+    provider: 'daytona' | 'modal',
+  ) => Promise<{ leaseId: string }>;
+  /** Release an unbound reservation when provider create never produced a resource. */
+  releaseSandboxCapacity?: (leaseId: string) => Promise<void>;
   /**
    * Durable scheduler-owned evidence for a provider create call. Backends
    * await this callback at the create boundary; it is not best-effort logging.

package/dist/bundling-sources/shared_libs/play-runtime/runtime-capacity-policy.ts

@@ -13,7 +13,6 @@ export const RUNTIME_CAPACITY_POLICY = {
     /** 32 Machines x 8 claim slots permits 256 concurrent launch/resume legs. */
     maxActiveLaneMachines: 32,
     workerSlotsPerMachine: 8,
-    perOrgConcurrency: 4,
     /** Queue age is an escape hatch for small-but-stuck backlogs. */
     scaleUpQueueAgeMs: 10_000,
     /** Bound one Fly reconciliation without turning backlog into a stampede. */
@@ -113,14 +112,6 @@ export function assertRuntimeCapacityPolicy(): void {
       'Receipt claim operations must leave at least five seconds for cancellation and response delivery.',
     );
   }
-  if (
-    RUNTIME_CAPACITY_POLICY.absurd.perOrgConcurrency >
-    ABSURD_GLOBAL_RUN_CONCURRENCY
-  ) {
-    throw new Error(
-      'Per-org runtime concurrency cannot exceed global runtime concurrency.',
-    );
-  }
   if (
     RUNTIME_CAPACITY_POLICY.absurd.activeLaneMachines >
     RUNTIME_CAPACITY_POLICY.absurd.maxActiveLaneMachines

package/dist/bundling-sources/shared_libs/play-runtime/transient-service-error.ts

@@ -8,11 +8,12 @@ export function transientServiceUnavailableDetail(
   if (error instanceof TypeError && /^fetch failed$/i.test(detail.trim())) {
     return detail;
   }
-  // Convex uses both an explicit ServiceUnavailable response and this generic
-  // InternalServerError envelope for short control-plane outages. The latter
-  // text is intentionally exact: application exceptions must not become
-  // retryable merely because they mention an internal-server error.
-  return /ServiceUnavailable|Service temporarily unavailable|temporarily unavailable \(Code:\s*\d+\)|"code"\s*:\s*"InternalServerError"[\s\S]*(?:Your request couldn't be completed\. Try again later\.|Your request timed out performing too many system operations\.)/i.test(
+  // Convex uses explicit ServiceUnavailable and ExpiredInQueue responses, as
+  // well as this generic InternalServerError envelope for short control-plane
+  // outages. The latter text is intentionally exact: application exceptions
+  // must not become retryable merely because they mention an internal-server
+  // error.
+  return /ServiceUnavailable|Service temporarily unavailable|temporarily unavailable \(Code:\s*\d+\)|"code"\s*:\s*"ExpiredInQueue"|"code"\s*:\s*"InternalServerError"[\s\S]*(?:Your request couldn't be completed\. Try again later\.|Your request timed out performing too many system operations\.)/i.test(
     detail,
   )
     ? detail

package/dist/bundling-sources/shared_libs/plays/authoring-contract.ts

@@ -71,6 +71,7 @@ export const PLAY_AUTHORING_CONTRACT_ISSUE_CODES = [
   'play_authoring_fetch_key_reused_in_loop',
   'play_authoring_binding_invalid',
   'play_authoring_input_schema_unresolved',
+  'tool_response_raw_access',
   'check_error',
   'docflow_compile_error',
   'docflow_binding_drift',

package/dist/bundling-sources/shared_libs/plays/bundling/index.ts

@@ -223,9 +223,12 @@ function sourceIdentityPath(
 ): string {
   if (!sourceIdentityRoot) return filePath;
   const identityRoot = resolve(sourceIdentityRoot);
-  const logicalPath = relative(identityRoot, resolve(filePath));
+  const resolvedFilePath = resolve(filePath);
+  const logicalPath = relative(identityRoot, resolvedFilePath);
+  if (!logicalPath) {
+    return basename(resolvedFilePath);
+  }
   if (
-    !logicalPath ||
     logicalPath === '..' ||
     logicalPath.startsWith(`..${sep}`) ||
     isAbsolute(logicalPath)

package/dist/cli/index.js

@@ -185,7 +185,7 @@ function configureProxyFromEnv() {
 configureProxyFromEnv();
 
 // src/cli/index.ts
-var import_promises9 = require("fs/promises");
+var import_promises10 = require("fs/promises");
 var import_node_path26 = require("path");
 var import_node_os19 = require("os");
 var import_commander4 = require("commander");
@@ -1047,7 +1047,7 @@ var SDK_RELEASE = {
   // 0.3.0 introduces raw-v2: complete scrubbed provider responses are
   // available at toolResponse.rawV2 while toolResponse.raw and all declared
   // getters keep their established compatibility behavior.
-  version: "0.3.0",
+  version: "0.3.2",
   updateSummary: "New raw-v2 tool responses preserve complete scrubbed provider envelopes at toolResponse.rawV2, including JSON:API included resources, links, cursors, and totals. Existing toolResponse.raw and declared getters keep working unchanged.",
   contracts: {
     api: {
@@ -1466,6 +1466,14 @@ var HttpClient = class {
             throw structuredToolError;
           }
           if (response.status === 429) {
+            if (options?.preserveRateLimitResponse && isMonitorRateLimitEnvelope(parsed)) {
+              throw new DeeplineError(
+                apiErrorMessage(parsed, response.status),
+                response.status,
+                apiErrorCodeFromResponse(parsed),
+                { response: parsed }
+              );
+            }
             const retryAfter = parseRetryAfter(response);
             lastError = new RateLimitError(retryAfter);
             if (attempt < maxRetries) {
@@ -1727,6 +1735,11 @@ function isProviderOriginatedHttpError(parsed) {
   const code = error?.code ?? response?.code;
   return failureOrigin === "provider" || code === "UPSTREAM_BLOCKED";
 }
+function isMonitorRateLimitEnvelope(parsed) {
+  const response = asRecord(parsed);
+  const error = asRecord(response?.error);
+  return error?.code === "monitor_upstream_rate_limited" && typeof error.message === "string";
+}
 function apiErrorCodeFromResponse(parsed) {
   const response = asRecord(parsed);
   const error = asRecord(response?.error);
@@ -6503,7 +6516,13 @@ var DeeplineClient = class {
       "/api/v2/monitors/deploy",
       {
         method: "POST",
-        body: definition
+        body: definition,
+        // A provider can reject a create with a 429 after Deepline has begun
+        // the lifecycle request. Do not replay a mutation or hide the server's
+        // monitor-specific recovery guidance behind a generic transport retry.
+        maxRetries: 0,
+        exactUrlOnly: true,
+        preserveRateLimitResponse: true
       }
     );
     if (definition.tool !== "deepline.analytics") return deployed;
@@ -11068,7 +11087,7 @@ Examples:
 }
 
 // src/cli/commands/enrich.ts
-var import_promises6 = require("fs/promises");
+var import_promises7 = require("fs/promises");
 var import_node_os10 = require("os");
 var import_node_path15 = require("path");
 var import_commander2 = require("commander");
@@ -11076,7 +11095,7 @@ var import_commander2 = require("commander");
 // src/cli/commands/play.ts
 var import_node_crypto6 = require("crypto");
 var import_node_fs12 = require("fs");
-var import_promises5 = require("fs/promises");
+var import_promises6 = require("fs/promises");
 var import_node_path14 = require("path");
 var import_sync5 = require("csv-parse/sync");
 
@@ -12784,6 +12803,7 @@ var import_node_os9 = require("os");
 var import_node_path13 = require("path");
 var import_node_url = require("url");
 var import_node_fs11 = require("fs");
+var import_promises5 = require("fs/promises");
 
 // ../shared_libs/plays/bundling/index.ts
 var import_node_crypto4 = require("crypto");
@@ -18314,7 +18334,7 @@ var PLAY_RUN_RESERVED_BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
 ]);
 async function pathExistsIncludingSymlink(path) {
   try {
-    await (0, import_promises5.lstat)(path);
+    await (0, import_promises6.lstat)(path);
     return true;
   } catch (error) {
     if (error.code === "ENOENT") {
@@ -18331,7 +18351,7 @@ function runIdFileTempPath(destination) {
 }
 async function removeRunIdTempFile(path) {
   try {
-    await (0, import_promises5.unlink)(path);
+    await (0, import_promises6.unlink)(path);
   } catch (error) {
     if (error.code !== "ENOENT") {
       throw error;
@@ -18348,7 +18368,7 @@ async function preflightRunIdFile(path) {
   const tempPath = runIdFileTempPath(destination);
   let handle = null;
   try {
-    handle = await (0, import_promises5.open)(tempPath, "wx", 384);
+    handle = await (0, import_promises6.open)(tempPath, "wx", 384);
     await handle.sync();
   } catch (error) {
     throw new Error(
@@ -18366,7 +18386,7 @@ async function readRunIdFile(destination) {
   }
   let parsed;
   try {
-    parsed = JSON.parse(await (0, import_promises5.readFile)(destination, "utf8"));
+    parsed = JSON.parse(await (0, import_promises6.readFile)(destination, "utf8"));
   } catch (error) {
     throw new Error(
       `--run-id-file destination contains invalid JSON: ${destination}. Refusing to overwrite it (${error instanceof Error ? error.message : String(error)}).`
@@ -18390,7 +18410,7 @@ async function writePlayRunIdFile(destination, runId) {
   const tempPath = runIdFileTempPath(destination);
   let handle = null;
   try {
-    handle = await (0, import_promises5.open)(tempPath, "wx", 384);
+    handle = await (0, import_promises6.open)(tempPath, "wx", 384);
     await handle.writeFile(
       `${JSON.stringify({ version: 1, runId })}
 `,
@@ -18400,8 +18420,8 @@ async function writePlayRunIdFile(destination, runId) {
     await handle.close();
     handle = null;
     try {
-      await (0, import_promises5.link)(tempPath, destination);
-      const directory = await (0, import_promises5.open)((0, import_node_path14.dirname)(destination), "r");
+      await (0, import_promises6.link)(tempPath, destination);
+      const directory = await (0, import_promises6.open)((0, import_node_path14.dirname)(destination), "r");
       try {
         await directory.sync();
       } finally {
@@ -27693,6 +27713,7 @@ var ENRICH_DEBUG_T0 = Date.now();
 var GENERATED_ENRICH_ROWS_TABLE_NAMESPACE = "deepline_enrich_rows";
 var SDK_ENRICH_TELEMETRY_TIMEOUT_MS = 1e4;
 var SDK_ENRICH_TELEMETRY_COMMAND_MAX_LENGTH = 2e4;
+var ENRICH_DEPRECATION_NOTICE = "DEPRECATION: `deepline enrich` is deprecated and no longer actively maintained. Use `deepline plays` for the supported workflow.\n";
 var ENRICH_AI_RUNTIME_COMPACT_TOOLS = /* @__PURE__ */ new Set([
   "ai_inference",
   "aiinference",
@@ -27866,7 +27887,7 @@ async function readAtFileReference(value, argumentName, strip = true) {
     throw new Error(`Invalid ${argumentName} value: empty @file path.`);
   }
   try {
-    const text = await (0, import_promises6.readFile)(filePath, "utf8");
+    const text = await (0, import_promises7.readFile)(filePath, "utf8");
     const normalized = text.replace(/^\uFEFF/, "");
     return strip ? normalized.trim() : normalized;
   } catch (error) {
@@ -28164,7 +28185,7 @@ async function buildPlanArgs(args) {
 async function assertInputCsvExists(inputCsv) {
   const path = (0, import_node_path15.resolve)(inputCsv);
   try {
-    const info = await (0, import_promises6.stat)(path);
+    const info = await (0, import_promises7.stat)(path);
     if (info.isFile()) {
       return;
     }
@@ -28185,8 +28206,8 @@ async function assertSafeOutputPath(inputCsv, outputPath) {
   }
   try {
     const [inputInfo, outputInfo] = await Promise.all([
-      (0, import_promises6.stat)(input2),
-      (0, import_promises6.stat)(output2)
+      (0, import_promises7.stat)(input2),
+      (0, import_promises7.stat)(output2)
     ]);
     if (inputInfo.dev === outputInfo.dev && inputInfo.ino === outputInfo.ino) {
       throw new Error(
@@ -28206,7 +28227,7 @@ async function assertSafeOutputPath(inputCsv, outputPath) {
 }
 async function regularFileExists(path) {
   try {
-    const info = await (0, import_promises6.stat)((0, import_node_path15.resolve)(path));
+    const info = await (0, import_promises7.stat)((0, import_node_path15.resolve)(path));
     return info.isFile();
   } catch (error) {
     const code = error && typeof error === "object" ? error.code : void 0;
@@ -28217,7 +28238,7 @@ async function regularFileExists(path) {
   }
 }
 async function readConfig(path) {
-  const source = await (0, import_promises6.readFile)((0, import_node_path15.resolve)(path), "utf8");
+  const source = await (0, import_promises7.readFile)((0, import_node_path15.resolve)(path), "utf8");
   let parsed;
   try {
     parsed = JSON.parse(source);
@@ -28638,7 +28659,7 @@ async function writeOutputCsv(outputPath, status, options) {
     ]),
     options?.config
   );
-  await (0, import_promises6.writeFile)(
+  await (0, import_promises7.writeFile)(
     (0, import_node_path15.resolve)(outputPath),
     csvStringFromRows(merged.rows, columns),
     "utf8"
@@ -30318,7 +30339,7 @@ async function persistEnrichFailureReport(input2) {
   }
   const stateDir = (0, import_node_path15.join)((0, import_node_os10.homedir)(), ".local", "deepline", "runtime", "state");
   const reportPrefix = input2.jobs.length > 0 ? "run-block-failures" : "enrich-issues";
-  await (0, import_promises6.mkdir)(stateDir, { recursive: true });
+  await (0, import_promises7.mkdir)(stateDir, { recursive: true });
   const reportPath = (0, import_node_path15.join)(
     stateDir,
     `${reportPrefix}-${Math.floor(Date.now() / 1e3)}-${process.pid}.json`
@@ -30344,7 +30365,7 @@ async function persistEnrichFailureReport(input2) {
   if (input2.rows.rowStart !== null && input2.rows.rowEnd !== null) {
     report.rows = { start: input2.rows.rowStart, end: input2.rows.rowEnd };
   }
-  await (0, import_promises6.writeFile)(reportPath, `${JSON.stringify(report, null, 2)}
+  await (0, import_promises7.writeFile)(reportPath, `${JSON.stringify(report, null, 2)}
 `, "utf8");
   return reportPath;
 }
@@ -31162,6 +31183,7 @@ function registerEnrichCommand(program) {
     "--max-credits-per-run <credits>",
     "Set a hard Deepline-credit ceiling enforced by the runtime for this run."
   ).action(async (options, _command) => {
+    process.stderr.write(ENRICH_DEPRECATION_NOTICE);
     if (currentEnrichArgs().some(
       (arg) => arg === "--no-open" || arg.startsWith("--no-open=")
     )) {
@@ -31247,13 +31269,13 @@ function registerEnrichCommand(program) {
       sdkEnrichTelemetryCompleted = true;
       await completeSdkEnrichTelemetry(sdkEnrichTelemetry, input2);
     };
-    const tempDir = await (0, import_promises6.mkdtemp)((0, import_node_path15.join)((0, import_node_os10.tmpdir)(), "deepline-enrich-play-"));
+    const tempDir = await (0, import_promises7.mkdtemp)((0, import_node_path15.join)((0, import_node_os10.tmpdir)(), "deepline-enrich-play-"));
     await emitSdkEnrichTelemetry(sdkEnrichTelemetry, "enrich_started");
     const tempPlay = (0, import_node_path15.join)(tempDir, "deepline-enrich.play.ts");
     let inPlaceTempDir = null;
     let inPlaceTempOutputPath = null;
     const inPlaceFinalOutputPath = options.inPlace ? (0, import_node_path15.resolve)(inputCsv) : null;
-    const inPlaceCommitOutputPath = options.inPlace ? (await (0, import_promises6.lstat)(inputCsv)).isSymbolicLink() ? await (0, import_promises6.realpath)(inputCsv) : inPlaceFinalOutputPath : null;
+    const inPlaceCommitOutputPath = options.inPlace ? (await (0, import_promises7.lstat)(inputCsv)).isSymbolicLink() ? await (0, import_promises7.realpath)(inputCsv) : inPlaceFinalOutputPath : null;
     const failureReportOutputPath = options.inPlace ? inPlaceFinalOutputPath : null;
     const enrichIssueFollowUpOutputPath = options.inPlace && inPlaceFinalOutputPath ? sidecarEnrichRowsExportPath(inPlaceFinalOutputPath) : null;
     let activeRunId2 = null;
@@ -31274,16 +31296,16 @@ function registerEnrichCommand(program) {
         return;
       }
       if (inPlaceTempDir) {
-        await (0, import_promises6.rm)(inPlaceTempDir, { recursive: true, force: true });
+        await (0, import_promises7.rm)(inPlaceTempDir, { recursive: true, force: true });
       }
-      inPlaceTempDir = await (0, import_promises6.mkdtemp)(
+      inPlaceTempDir = await (0, import_promises7.mkdtemp)(
         (0, import_node_path15.join)(
           (0, import_node_path15.dirname)(inPlaceCommitOutputPath ?? (0, import_node_path15.resolve)(inputCsv)),
           ".deepline-enrich-in-place-"
         )
       );
       inPlaceTempOutputPath = (0, import_node_path15.join)(inPlaceTempDir, "output.csv");
-      await (0, import_promises6.copyFile)((0, import_node_path15.resolve)(inputCsv), inPlaceTempOutputPath);
+      await (0, import_promises7.copyFile)((0, import_node_path15.resolve)(inputCsv), inPlaceTempOutputPath);
       outputPath = inPlaceTempOutputPath;
     };
     const commitInPlaceOutput = async (exportResult) => {
@@ -31291,12 +31313,12 @@ function registerEnrichCommand(program) {
         return exportResult;
       }
       const committedTempDir = inPlaceTempDir;
-      await (0, import_promises6.rename)(inPlaceTempOutputPath, inPlaceCommitOutputPath);
+      await (0, import_promises7.rename)(inPlaceTempOutputPath, inPlaceCommitOutputPath);
       inPlaceTempDir = null;
       inPlaceTempOutputPath = null;
       outputPath = inPlaceFinalOutputPath;
       if (committedTempDir) {
-        await (0, import_promises6.rm)(committedTempDir, { recursive: true, force: true });
+        await (0, import_promises7.rm)(committedTempDir, { recursive: true, force: true });
       }
       if (!exportResult) {
         return null;
@@ -31309,7 +31331,7 @@ function registerEnrichCommand(program) {
     try {
       process.once("SIGINT", onSigint);
       process.once("SIGTERM", onSigterm);
-      await (0, import_promises6.writeFile)(tempPlay, playSource, "utf8");
+      await (0, import_promises7.writeFile)(tempPlay, playSource, "utf8");
       if (options.inPlace) {
         await prepareInPlaceOutput();
       }
@@ -31503,11 +31525,11 @@ function registerEnrichCommand(program) {
       process.removeListener("SIGINT", onSigint);
       process.removeListener("SIGTERM", onSigterm);
       if (inPlaceTempDir) {
-        await (0, import_promises6.rm)(inPlaceTempDir, { recursive: true, force: true });
+        await (0, import_promises7.rm)(inPlaceTempDir, { recursive: true, force: true });
       } else if (inPlaceTempOutputPath) {
-        await (0, import_promises6.rm)(inPlaceTempOutputPath, { force: true });
+        await (0, import_promises7.rm)(inPlaceTempOutputPath, { force: true });
       }
-      await (0, import_promises6.rm)(tempDir, { recursive: true, force: true });
+      await (0, import_promises7.rm)(tempDir, { recursive: true, force: true });
     }
   });
 }
@@ -32399,7 +32421,7 @@ Examples:
 
 // src/cli/commands/monitors.ts
 var import_node_fs14 = require("fs");
-var import_promises7 = require("readline/promises");
+var import_promises8 = require("readline/promises");
 var JSON_OPTION_DESCRIPTION = "Emit JSON output. Also automatic when stdout is piped";
 function withJsonOption(command) {
   return command.option("--json", JSON_OPTION_DESCRIPTION);
@@ -33168,7 +33190,7 @@ async function handleMonitorsValidate(key, options) {
   if (result.valid === false) process.exitCode = 7;
 }
 async function confirmMonitorDelete(key, options) {
-  const rl = (0, import_promises7.createInterface)({
+  const rl = (0, import_promises8.createInterface)({
     input: process.stdin,
     output: process.stderr
   });
@@ -40185,7 +40207,7 @@ Examples:
 }
 
 // src/cli/commands/workflow.ts
-var import_promises8 = require("fs/promises");
+var import_promises9 = require("fs/promises");
 var import_node_path24 = require("path");
 
 // src/cli/workflow-to-play.ts
@@ -40403,7 +40425,7 @@ function readStatus(payload) {
 }
 async function readJsonOption(payload, file) {
   if (file) {
-    const raw = await (0, import_promises8.readFile)((0, import_node_path24.resolve)(file), "utf8");
+    const raw = await (0, import_promises9.readFile)((0, import_node_path24.resolve)(file), "utf8");
     return JSON.parse(raw);
   }
   if (payload) {
@@ -40438,8 +40460,8 @@ async function transformOne(api, workflowId, outDir, publish) {
       { workflowName: workflow.name, version: revision.version }
     );
     const file = (0, import_node_path24.join)((0, import_node_path24.resolve)(outDir), `${compiled.playName}.play.ts`);
-    await (0, import_promises8.mkdir)((0, import_node_path24.dirname)(file), { recursive: true });
-    await (0, import_promises8.writeFile)(file, compiled.sourceCode, "utf8");
+    await (0, import_promises9.mkdir)((0, import_node_path24.dirname)(file), { recursive: true });
+    await (0, import_promises9.writeFile)(file, compiled.sourceCode, "utf8");
     let published = false;
     if (publish) {
       const code = await handlePlayPublish([file]);
@@ -41573,10 +41595,10 @@ function topLevelCommandKnown(program, commandName) {
   );
 }
 async function runPlayRunnerHealthCheck() {
-  const dir = await (0, import_promises9.mkdtemp)((0, import_node_path26.join)((0, import_node_os19.tmpdir)(), "deepline-health-play-"));
+  const dir = await (0, import_promises10.mkdtemp)((0, import_node_path26.join)((0, import_node_os19.tmpdir)(), "deepline-health-play-"));
   const file = (0, import_node_path26.join)(dir, "health-check.play.ts");
   try {
-    await (0, import_promises9.writeFile)(
+    await (0, import_promises10.writeFile)(
       file,
       [
         "import { definePlay } from 'deepline';",
@@ -41625,7 +41647,7 @@ async function runPlayRunnerHealthCheck() {
       }
     };
   } finally {
-    await (0, import_promises9.rm)(dir, { recursive: true, force: true });
+    await (0, import_promises10.rm)(dir, { recursive: true, force: true });
   }
 }
 function pickString(value, ...keys) {

package/dist/cli/index.mjs

@@ -1033,7 +1033,7 @@ var SDK_RELEASE = {
   // 0.3.0 introduces raw-v2: complete scrubbed provider responses are
   // available at toolResponse.rawV2 while toolResponse.raw and all declared
   // getters keep their established compatibility behavior.
-  version: "0.3.0",
+  version: "0.3.2",
   updateSummary: "New raw-v2 tool responses preserve complete scrubbed provider envelopes at toolResponse.rawV2, including JSON:API included resources, links, cursors, and totals. Existing toolResponse.raw and declared getters keep working unchanged.",
   contracts: {
     api: {
@@ -1452,6 +1452,14 @@ var HttpClient = class {
             throw structuredToolError;
           }
           if (response.status === 429) {
+            if (options?.preserveRateLimitResponse && isMonitorRateLimitEnvelope(parsed)) {
+              throw new DeeplineError(
+                apiErrorMessage(parsed, response.status),
+                response.status,
+                apiErrorCodeFromResponse(parsed),
+                { response: parsed }
+              );
+            }
             const retryAfter = parseRetryAfter(response);
             lastError = new RateLimitError(retryAfter);
             if (attempt < maxRetries) {
@@ -1713,6 +1721,11 @@ function isProviderOriginatedHttpError(parsed) {
   const code = error?.code ?? response?.code;
   return failureOrigin === "provider" || code === "UPSTREAM_BLOCKED";
 }
+function isMonitorRateLimitEnvelope(parsed) {
+  const response = asRecord(parsed);
+  const error = asRecord(response?.error);
+  return error?.code === "monitor_upstream_rate_limited" && typeof error.message === "string";
+}
 function apiErrorCodeFromResponse(parsed) {
   const response = asRecord(parsed);
   const error = asRecord(response?.error);
@@ -6489,7 +6502,13 @@ var DeeplineClient = class {
       "/api/v2/monitors/deploy",
       {
         method: "POST",
-        body: definition
+        body: definition,
+        // A provider can reject a create with a 429 after Deepline has begun
+        // the lifecycle request. Do not replay a mutation or hide the server's
+        // monitor-specific recovery guidance behind a generic transport retry.
+        maxRetries: 0,
+        exactUrlOnly: true,
+        preserveRateLimitResponse: true
       }
     );
     if (definition.tool !== "deepline.analytics") return deployed;
@@ -11080,7 +11099,7 @@ import {
   mkdir as mkdir4,
   mkdtemp,
   readFile as readFile3,
-  realpath as realpath2,
+  realpath as realpath3,
   rename,
   rm,
   stat as stat3,
@@ -12828,6 +12847,7 @@ import { tmpdir as tmpdir3 } from "os";
 import { dirname as dirname8, join as join9, resolve as resolve10 } from "path";
 import { fileURLToPath } from "url";
 import { existsSync as existsSync8 } from "fs";
+import { realpath as realpath2 } from "fs/promises";
 
 // ../shared_libs/plays/bundling/index.ts
 import { createHash as createHash2 } from "crypto";
@@ -27753,6 +27773,7 @@ var ENRICH_DEBUG_T0 = Date.now();
 var GENERATED_ENRICH_ROWS_TABLE_NAMESPACE = "deepline_enrich_rows";
 var SDK_ENRICH_TELEMETRY_TIMEOUT_MS = 1e4;
 var SDK_ENRICH_TELEMETRY_COMMAND_MAX_LENGTH = 2e4;
+var ENRICH_DEPRECATION_NOTICE = "DEPRECATION: `deepline enrich` is deprecated and no longer actively maintained. Use `deepline plays` for the supported workflow.\n";
 var ENRICH_AI_RUNTIME_COMPACT_TOOLS = /* @__PURE__ */ new Set([
   "ai_inference",
   "aiinference",
@@ -31222,6 +31243,7 @@ function registerEnrichCommand(program) {
     "--max-credits-per-run <credits>",
     "Set a hard Deepline-credit ceiling enforced by the runtime for this run."
   ).action(async (options, _command) => {
+    process.stderr.write(ENRICH_DEPRECATION_NOTICE);
     if (currentEnrichArgs().some(
       (arg) => arg === "--no-open" || arg.startsWith("--no-open=")
     )) {
@@ -31313,7 +31335,7 @@ function registerEnrichCommand(program) {
     let inPlaceTempDir = null;
     let inPlaceTempOutputPath = null;
     const inPlaceFinalOutputPath = options.inPlace ? resolve12(inputCsv) : null;
-    const inPlaceCommitOutputPath = options.inPlace ? (await lstat2(inputCsv)).isSymbolicLink() ? await realpath2(inputCsv) : inPlaceFinalOutputPath : null;
+    const inPlaceCommitOutputPath = options.inPlace ? (await lstat2(inputCsv)).isSymbolicLink() ? await realpath3(inputCsv) : inPlaceFinalOutputPath : null;
     const failureReportOutputPath = options.inPlace ? inPlaceFinalOutputPath : null;
     const enrichIssueFollowUpOutputPath = options.inPlace && inPlaceFinalOutputPath ? sidecarEnrichRowsExportPath(inPlaceFinalOutputPath) : null;
     let activeRunId2 = null;

package/dist/index.js

@@ -783,7 +783,7 @@ var SDK_RELEASE = {
   // 0.3.0 introduces raw-v2: complete scrubbed provider responses are
   // available at toolResponse.rawV2 while toolResponse.raw and all declared
   // getters keep their established compatibility behavior.
-  version: "0.3.0",
+  version: "0.3.2",
   updateSummary: "New raw-v2 tool responses preserve complete scrubbed provider envelopes at toolResponse.rawV2, including JSON:API included resources, links, cursors, and totals. Existing toolResponse.raw and declared getters keep working unchanged.",
   contracts: {
     api: {
@@ -1202,6 +1202,14 @@ var HttpClient = class {
             throw structuredToolError;
           }
           if (response.status === 429) {
+            if (options?.preserveRateLimitResponse && isMonitorRateLimitEnvelope(parsed)) {
+              throw new DeeplineError(
+                apiErrorMessage(parsed, response.status),
+                response.status,
+                apiErrorCodeFromResponse(parsed),
+                { response: parsed }
+              );
+            }
             const retryAfter = parseRetryAfter(response);
             lastError = new RateLimitError(retryAfter);
             if (attempt < maxRetries) {
@@ -1463,6 +1471,11 @@ function isProviderOriginatedHttpError(parsed) {
   const code = error?.code ?? response?.code;
   return failureOrigin === "provider" || code === "UPSTREAM_BLOCKED";
 }
+function isMonitorRateLimitEnvelope(parsed) {
+  const response = asRecord(parsed);
+  const error = asRecord(response?.error);
+  return error?.code === "monitor_upstream_rate_limited" && typeof error.message === "string";
+}
 function apiErrorCodeFromResponse(parsed) {
   const response = asRecord(parsed);
   const error = asRecord(response?.error);
@@ -6239,7 +6252,13 @@ var DeeplineClient = class {
       "/api/v2/monitors/deploy",
       {
         method: "POST",
-        body: definition
+        body: definition,
+        // A provider can reject a create with a 429 after Deepline has begun
+        // the lifecycle request. Do not replay a mutation or hide the server's
+        // monitor-specific recovery guidance behind a generic transport retry.
+        maxRetries: 0,
+        exactUrlOnly: true,
+        preserveRateLimitResponse: true
       }
     );
     if (definition.tool !== "deepline.analytics") return deployed;

package/dist/index.mjs

@@ -706,7 +706,7 @@ var SDK_RELEASE = {
   // 0.3.0 introduces raw-v2: complete scrubbed provider responses are
   // available at toolResponse.rawV2 while toolResponse.raw and all declared
   // getters keep their established compatibility behavior.
-  version: "0.3.0",
+  version: "0.3.2",
   updateSummary: "New raw-v2 tool responses preserve complete scrubbed provider envelopes at toolResponse.rawV2, including JSON:API included resources, links, cursors, and totals. Existing toolResponse.raw and declared getters keep working unchanged.",
   contracts: {
     api: {
@@ -1125,6 +1125,14 @@ var HttpClient = class {
             throw structuredToolError;
           }
           if (response.status === 429) {
+            if (options?.preserveRateLimitResponse && isMonitorRateLimitEnvelope(parsed)) {
+              throw new DeeplineError(
+                apiErrorMessage(parsed, response.status),
+                response.status,
+                apiErrorCodeFromResponse(parsed),
+                { response: parsed }
+              );
+            }
             const retryAfter = parseRetryAfter(response);
             lastError = new RateLimitError(retryAfter);
             if (attempt < maxRetries) {
@@ -1386,6 +1394,11 @@ function isProviderOriginatedHttpError(parsed) {
   const code = error?.code ?? response?.code;
   return failureOrigin === "provider" || code === "UPSTREAM_BLOCKED";
 }
+function isMonitorRateLimitEnvelope(parsed) {
+  const response = asRecord(parsed);
+  const error = asRecord(response?.error);
+  return error?.code === "monitor_upstream_rate_limited" && typeof error.message === "string";
+}
 function apiErrorCodeFromResponse(parsed) {
   const response = asRecord(parsed);
   const error = asRecord(response?.error);
@@ -6162,7 +6175,13 @@ var DeeplineClient = class {
       "/api/v2/monitors/deploy",
       {
         method: "POST",
-        body: definition
+        body: definition,
+        // A provider can reject a create with a 429 after Deepline has begun
+        // the lifecycle request. Do not replay a mutation or hide the server's
+        // monitor-specific recovery guidance behind a generic transport retry.
+        maxRetries: 0,
+        exactUrlOnly: true,
+        preserveRateLimitResponse: true
       }
     );
     if (definition.tool !== "deepline.analytics") return deployed;

package/dist/plays/bundle-play-file.mjs

@@ -9,6 +9,7 @@ import { tmpdir as tmpdir2 } from "os";
 import { dirname as dirname3, join as join3, resolve as resolve3 } from "path";
 import { fileURLToPath } from "url";
 import { existsSync as existsSync2 } from "fs";
+import { realpath as realpath2 } from "fs/promises";
 
 // ../shared_libs/plays/bundling/index.ts
 import { createHash } from "crypto";
@@ -5286,8 +5287,12 @@ function sha256(value) {
 function sourceIdentityPath(filePath, sourceIdentityRoot) {
   if (!sourceIdentityRoot) return filePath;
   const identityRoot = resolve(sourceIdentityRoot);
-  const logicalPath = relative(identityRoot, resolve(filePath));
-  if (!logicalPath || logicalPath === ".." || logicalPath.startsWith(`..${sep}`) || isAbsolute(logicalPath)) {
+  const resolvedFilePath = resolve(filePath);
+  const logicalPath = relative(identityRoot, resolvedFilePath);
+  if (!logicalPath) {
+    return basename(resolvedFilePath);
+  }
+  if (logicalPath === ".." || logicalPath.startsWith(`..${sep}`) || isAbsolute(logicalPath)) {
     return filePath;
   }
   return logicalPath.split(/[\\/]+/).join("/");
@@ -7201,10 +7206,17 @@ function createSdkPlayBundlingAdapter() {
   };
 }
 async function bundlePlayFile2(filePath, options = {}) {
+  const localWorkspaceRoot = dirname3(resolve3(filePath));
+  const sourceIdentityRoot = await realpath2(localWorkspaceRoot).catch(
+    () => localWorkspaceRoot
+  );
   const result = await bundlePlayFile(filePath, {
     target: options.target ?? defaultPlayBundleTarget(),
     exportName: options.exportName,
-    adapter: createSdkPlayBundlingAdapter()
+    adapter: {
+      ...createSdkPlayBundlingAdapter(),
+      sourceIdentityRoot
+    }
   });
   if (result.success)
     validatePlaySourceFilesHaveNoInlineSecrets(result.sourceFiles);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepline",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "GTM data CLI and TypeScript SDK for coding agents",
   "license": "MIT",
   "homepage": "https://code.deepline.com",