deepline 0.1.221 → 0.1.222

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

@@ -108,10 +108,10 @@ export const SDK_RELEASE = {
   // 0.1.175 ships loud `deepline enrich` empty-waterfall reporting.
   // 0.1.220 deprecates SDK CLI versions below 0.1.219 and updates them
   // automatically without blocking their current command.
-  version: '0.1.221',
+  version: '0.1.222',
   apiContract: '2026-06-dataset-handle-results-hard-cutover',
   supportPolicy: {
-    latest: '0.1.221',
+    latest: '0.1.222',
     minimumSupported: '0.1.53',
     deprecatedBelow: '0.1.219',
     commandMinimumSupported: [

package/dist/bundling-sources/shared_libs/play-runtime/context.ts

@@ -288,6 +288,9 @@ const MAP_INCREMENTAL_PERSIST_CHUNK_ROWS = 100;
 const MAP_INCREMENTAL_PERSIST_CHUNK_BYTES = 1 * 1024 * 1024;
 const MAP_INCREMENTAL_PERSIST_INTERVAL_MS = 100;
 const MAP_FRAME_FLUSH_INTERVAL_MS = 250;
+// Batchable calls wait at most this long for same-key row continuations. The
+// window is fixed from the first item and never resets on later arrivals.
+const TOOL_BATCH_COALESCE_WINDOW_MS = 5;
 const TOOL_RETRY_AFTER_FALLBACK_MS = 1_000;
 const TOOL_RETRY_HEARTBEAT_INTERVAL_MS = 30_000;
 const DEEPLINEAGENT_TOOL_RUNTIME_TIMEOUT_MS = 15 * 60 * 1000;
@@ -1196,6 +1199,14 @@ function createPacingResolver(
 export class PlayContextImpl {
   private rowStates = new Map<number, RowState>();
   private toolCallQueue: ToolCallRequest[] = [];
+  /**
+   * Fixed, non-resetting coalescing deadlines for batchable ready work. A
+   * deadline starts when the first request enters an empty batch bucket. New
+   * arrivals never push it back, so sustained traffic cannot starve dispatch.
+   */
+  private readonly toolBatchQueuedAtByKey = new Map<string, number>();
+  private readonly toolDispatcherWakeWaiters = new Set<() => void>();
+  private toolDispatcherFailure: unknown | null = null;
   private toolCallResolvers = new Map<
     string,
     { resolve: (value: unknown) => void; reject: (reason: unknown) => void }
@@ -6064,33 +6075,172 @@ export class PlayContextImpl {
     }
   }
 
+  private toolBatchCoalesceKey(request: ToolCallRequest): string | null {
+    const strategy =
+      this.#options.getBatchOperationStrategy?.(request.toolId) ?? null;
+    if (!strategy) return null;
+    return [
+      request.toolId,
+      request.executionAuthScopeDigest ?? '',
+      String(strategy.toBucketKey(request.input)),
+    ].join('\u0000');
+  }
+
+  private wakeToolDispatcher(): void {
+    const waiters = [...this.toolDispatcherWakeWaiters];
+    this.toolDispatcherWakeWaiters.clear();
+    for (const wake of waiters) wake();
+  }
+
+  private enqueueToolCall(request: ToolCallRequest): void {
+    if (this.toolDispatcherFailure != null) {
+      const resolver = this.toolCallResolvers.get(request.callId);
+      if (resolver) {
+        resolver.reject(this.toolDispatcherFailure);
+        this.toolCallResolvers.delete(request.callId);
+      }
+      return;
+    }
+    this.toolCallQueue.push(request);
+    const batchKey = this.toolBatchCoalesceKey(request);
+    if (batchKey && !this.toolBatchQueuedAtByKey.has(batchKey)) {
+      this.toolBatchQueuedAtByKey.set(batchKey, Date.now());
+    }
+    this.wakeToolDispatcher();
+  }
+
+  private rejectQueuedToolCalls(error: unknown): void {
+    const queued = this.toolCallQueue;
+    this.toolCallQueue = [];
+    this.toolBatchQueuedAtByKey.clear();
+    for (const request of queued) {
+      const resolver = this.toolCallResolvers.get(request.callId);
+      if (!resolver) continue;
+      resolver.reject(error);
+      this.toolCallResolvers.delete(request.callId);
+    }
+  }
+
+  private takeDispatchableToolCalls(nowMs: number): {
+    requests: ToolCallRequest[];
+    nextDeadlineMs: number | null;
+  } {
+    if (this.toolCallQueue.length === 0) {
+      return { requests: [], nextDeadlineMs: null };
+    }
+
+    const batchCounts = new Map<string, number>();
+    const batchMaxSizes = new Map<string, number>();
+    for (const request of this.toolCallQueue) {
+      const batchKey = this.toolBatchCoalesceKey(request);
+      if (!batchKey) continue;
+      batchCounts.set(batchKey, (batchCounts.get(batchKey) ?? 0) + 1);
+      const strategy =
+        this.#options.getBatchOperationStrategy?.(request.toolId) ?? null;
+      if (strategy) batchMaxSizes.set(batchKey, strategy.maxBatchSize);
+    }
+
+    const readyBatchKeys = new Set<string>();
+    let nextDeadlineMs: number | null = null;
+    for (const [batchKey, count] of batchCounts) {
+      const queuedAt = this.toolBatchQueuedAtByKey.get(batchKey) ?? nowMs;
+      if (!this.toolBatchQueuedAtByKey.has(batchKey)) {
+        this.toolBatchQueuedAtByKey.set(batchKey, queuedAt);
+      }
+      const deadline = queuedAt + TOOL_BATCH_COALESCE_WINDOW_MS;
+      const maxBatchSize = batchMaxSizes.get(batchKey) ?? 1;
+      if (count >= maxBatchSize || deadline <= nowMs) {
+        readyBatchKeys.add(batchKey);
+      } else {
+        nextDeadlineMs =
+          nextDeadlineMs == null
+            ? deadline
+            : Math.min(nextDeadlineMs, deadline);
+      }
+    }
+
+    const requests: ToolCallRequest[] = [];
+    const remaining: ToolCallRequest[] = [];
+    for (const request of this.toolCallQueue) {
+      const batchKey = this.toolBatchCoalesceKey(request);
+      if (!batchKey || readyBatchKeys.has(batchKey)) {
+        requests.push(request);
+      } else {
+        remaining.push(request);
+      }
+    }
+    this.toolCallQueue = remaining;
+    for (const batchKey of readyBatchKeys) {
+      this.toolBatchQueuedAtByKey.delete(batchKey);
+    }
+    return { requests, nextDeadlineMs };
+  }
+
+  private waitForToolDispatcherWake(deadlineMs: number | null): Promise<void> {
+    return new Promise((resolve) => {
+      let timer: ReturnType<typeof setTimeout> | null = null;
+      const wake = () => {
+        if (timer) clearTimeout(timer);
+        this.toolDispatcherWakeWaiters.delete(wake);
+        resolve();
+      };
+      this.toolDispatcherWakeWaiters.add(wake);
+      if (deadlineMs != null) {
+        timer = setTimeout(wake, Math.max(0, deadlineMs - Date.now()));
+      }
+    });
+  }
+
   private async drainQueuedWork<T>(promises: Promise<T>[]): Promise<void> {
-    // Drain loop: each pass resolves queued tool calls.
-    // When a batch resolves, rows resume and may queue MORE calls
-    // (e.g. row does tools.execute('a') then tools.execute('b') sequentially).
-    // We keep looping until nothing new is queued and all rows finish.
-    //
-    // Important: an unresolved Promise by itself does not keep Node alive. The
-    // play runner is a short-lived child process, so parking on
-    // Promise.allSettled(promises) while there is no timer/socket/file handle can
-    // let Node exit 0 before main() emits the result envelope. That presents as
-    // "Local play runner produced no result" even though the real bug was a
-    // map row waiting for queued tool work. Always race row settlement
-    // against a small timer and re-check the queues instead of blocking forever
-    // on promises that may be waiting for this drain loop to do the next batch.
-    const raceSettled = () =>
-      Promise.race([
-        Promise.allSettled(promises).then(() => 'done' as const),
-        new Promise<'pending'>((r) => setTimeout(() => r('pending'), 50)),
-      ]);
-
-    let pass = 0;
-    while (true) {
-      const hasPendingWork = this.toolCallQueue.length > 0;
-
-      if (!hasPendingWork) {
-        const status = await raceSettled();
-        if (status === 'done' && this.toolCallQueue.length === 0) {
+    // One dispatcher owns ready work, fixed batch coalescing deadlines, and
+    // the in-flight registry. A row resumes after its own receipt persists; it
+    // never waits for unrelated sibling calls from the previous column.
+    const inFlightToolExecutions = new Set<Promise<void>>();
+    let rowsSettled = false;
+    void Promise.allSettled(promises).then(() => {
+      rowsSettled = true;
+      this.wakeToolDispatcher();
+    });
+    // A pending Promise does not keep a short-lived Node runner alive. Keep one
+    // handle open without polling scheduler state; actual work wakes the
+    // dispatcher through queue/in-flight/row-settlement signals.
+    const keepAlive = setInterval(() => undefined, 1_000);
+    try {
+      let pass = 0;
+      while (true) {
+        if (this.toolDispatcherFailure != null) {
+          this.rejectQueuedToolCalls(this.toolDispatcherFailure);
+          await Promise.allSettled([...inFlightToolExecutions]);
+          throw this.toolDispatcherFailure;
+        }
+
+        const dispatchable = this.takeDispatchableToolCalls(Date.now());
+        if (dispatchable.requests.length > 0) {
+          pass += 1;
+          this.log(`  Batch pass ${pass}`);
+          this.log(
+            `  Dispatcher launch: ready=${dispatchable.requests.length} ` +
+              `queued=${this.toolCallQueue.length} ` +
+              `in_flight_groups=${inFlightToolExecutions.size}`,
+          );
+          const tracked = this.executeBatchedToolCalls(dispatchable.requests)
+            .catch((error) => {
+              this.toolDispatcherFailure ??= error;
+              this.rejectQueuedToolCalls(error);
+            })
+            .finally(() => {
+              inFlightToolExecutions.delete(tracked);
+              this.wakeToolDispatcher();
+            });
+          inFlightToolExecutions.add(tracked);
+          continue;
+        }
+
+        if (
+          rowsSettled &&
+          this.toolCallQueue.length === 0 &&
+          inFlightToolExecutions.size === 0
+        ) {
           if (!this.activeDatasetStep) {
             const childPlaySuspension =
               this.consumePendingChildPlaySuspension();
@@ -6101,23 +6251,10 @@ export class PlayContextImpl {
           break;
         }
 
-        // Promises are still running, or they settled while scheduling one last
-        // batch. Give resolver microtasks a turn, then loop back and drain any
-        // newly queued work. This timer is deliberately tiny; it is here for
-        // correctness/liveness, not throughput throttling.
-        await new Promise((r) => setTimeout(r, 10));
-        continue;
-      }
-
-      pass++;
-      this.log(`  Batch pass ${pass}`);
-      this.log(
-        `  Queue depth before drain: tool_calls=${this.toolCallQueue.length}`,
-      );
-
-      if (this.toolCallQueue.length > 0) {
-        await this.executeBatchedToolCalls();
+        await this.waitForToolDispatcherWake(dispatchable.nextDeadlineMs);
       }
+    } finally {
+      clearInterval(keepAlive);
     }
   }
 
@@ -6392,7 +6529,7 @@ export class PlayContextImpl {
           toolId,
           options?.timeoutMs,
         );
-        this.toolCallQueue.push({
+        this.enqueueToolCall({
           callId,
           cacheKey: toolResultCacheKey,
           cacheable: cacheableToolResult,
@@ -7407,10 +7544,9 @@ export class PlayContextImpl {
 
   // ——— Batched tool call execution ———
 
-  private async executeBatchedToolCalls(): Promise<void> {
-    const queuedToolCalls = this.toolCallQueue;
-    this.toolCallQueue = [];
-
+  private async executeBatchedToolCalls(
+    queuedToolCalls: ToolCallRequest[],
+  ): Promise<void> {
     // Group by toolId
     const byTool = new Map<string, ToolCallRequest[]>();
     for (const req of queuedToolCalls) {
@@ -7418,7 +7554,7 @@ export class PlayContextImpl {
       byTool.get(req.toolId)!.push(req);
     }
 
-    await Promise.all(
+    const toolSettlements = await Promise.allSettled(
       [...byTool.entries()].map(async ([toolId, requests]) => {
         this.log(`Executing tool batch ${toolId}: ${requests.length} calls`);
         const liveStepResults = new Map<string, unknown>();
@@ -8341,6 +8477,11 @@ export class PlayContextImpl {
         }
       }),
     );
+    const rejected = toolSettlements.find(
+      (settlement): settlement is PromiseRejectedResult =>
+        settlement.status === 'rejected',
+    );
+    if (rejected) throw rejected.reason;
   }
 
   private async executeResolvedPlay(

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

@@ -7,17 +7,15 @@ import { isIsolatedRuntimeSchedulerSchema } from '@shared_libs/play-runtime/runt
 
 const DAYTONA_CREATE_TIMEOUT_SECONDS = 10;
 const DAYTONA_CREATE_RETRY_DELAYS_MS = [0, 500, 1_500] as const;
-const DAYTONA_AUTO_STOP_INTERVAL_MINUTES = 5;
+// A detached runner is bounded by both the play runtime ceiling and Daytona's
+// own inactivity stop. No background activity refresh keeps a wedged sandbox
+// alive past those limits.
+const DAYTONA_AUTO_STOP_INTERVAL_MINUTES = 30;
 const DAYTONA_AUTO_ARCHIVE_INTERVAL_MINUTES = 15;
 const DAYTONA_SANDBOX_LABEL_SOURCE = 'deepline-play-runner';
-// The hosted Daytona API pins sandbox resources to the creating snapshot: it
-// rejects create-time resource overrides for snapshot sandboxes (400 "Cannot
-// specify Sandbox resources when using a snapshot") and does not serve
-// POST /sandbox/:id/resize (404 "Cannot POST"). The resource boundary is
-// therefore the default snapshot's grant, verified against these pins after
-// create. If Daytona changes the default snapshot's resources, sandbox
-// acquisition fails loudly instead of silently running plays on a different
-// compute boundary; bump these pins deliberately when that happens.
+// The sandbox must be created at its final resource boundary. Do not add a
+// resize call here: sandbox acquisition is launch-critical, and every extra
+// control-plane round trip raises cold-start latency.
 export const DAYTONA_SANDBOX_CPU = 1;
 export const DAYTONA_SANDBOX_MEMORY_GIB = 1;
 export const DAYTONA_SANDBOX_DISK_GIB = 3;

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

@@ -132,10 +132,7 @@ function redactDaytonaErrorDetail(value: string): string {
       '$1[redacted]',
     )
     .replace(/(bearer\s+)[^\s,;]+/gi, '$1[redacted]')
-    .replace(
-      /((?:api[_-]?key|token)\s*[=:]\s*)[^\s,;]+/gi,
-      '$1[redacted]',
-    )
+    .replace(/((?:api[_-]?key|token)\s*[=:]\s*)[^\s,;]+/gi, '$1[redacted]')
     .replace(/\s+/g, ' ')
     .trim()
     .slice(0, 1_000);

package/dist/bundling-sources/shared_libs/play-runtime/runtime-constants.ts

@@ -1,12 +1,12 @@
 /** Maximum active user-code runtime for a standard play, in seconds. */
-export const STANDARD_PLAY_RUNTIME_LIMIT_SECONDS = 20 * 60;
-export const STANDARD_PLAY_RUNTIME_LIMIT_LABEL = '20 minutes';
+export const STANDARD_PLAY_RUNTIME_LIMIT_SECONDS = 30 * 60;
+export const STANDARD_PLAY_RUNTIME_LIMIT_LABEL = '30 minutes';
 
 /**
  * Runner timeout includes setup, cleanup, and billing headroom after the
  * user-code runtime cap.
  */
-export const PLAY_RUNNER_TIMEOUT_SECONDS = 30 * 60;
+export const PLAY_RUNNER_TIMEOUT_SECONDS = 40 * 60;
 
 /** TTL for workflow executor tokens, in seconds. */
 export const WORKFLOW_EXECUTOR_TOKEN_TTL_SECONDS = PLAY_RUNNER_TIMEOUT_SECONDS;

package/dist/bundling-sources/shared_libs/play-runtime/scheduler-backend.ts

@@ -173,6 +173,7 @@ export type PlaySchedulerSubmitInput = {
    * case the worker falls back to the dev-collapse id (today's queue).
    */
   absurdReleaseId?: string | null;
+  absurdReleaseEnvironment?: 'preview' | 'production';
   /** Request-scoped Vercel Deployment Protection bypass for preview runtime callbacks. */
   vercelProtectionBypassToken?: string | null;
   /** Request-scoped, dev-only runtime fault injection header for black-box durability tests. */

package/dist/cli/index.js

@@ -625,10 +625,10 @@ var SDK_RELEASE = {
   // 0.1.175 ships loud `deepline enrich` empty-waterfall reporting.
   // 0.1.220 deprecates SDK CLI versions below 0.1.219 and updates them
   // automatically without blocking their current command.
-  version: "0.1.221",
+  version: "0.1.222",
   apiContract: "2026-06-dataset-handle-results-hard-cutover",
   supportPolicy: {
-    latest: "0.1.221",
+    latest: "0.1.222",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.219",
     commandMinimumSupported: [
@@ -5350,6 +5350,12 @@ function printCommandEnvelope(envelope, options = {}) {
 }
 
 // src/cli/commands/admin.ts
+function laneStatusLine(input2) {
+  if (input2.lane) {
+    return `status: ${input2.lane.status}${input2.lane.active ? " (active)" : ""}`;
+  }
+  return input2.registration ? `status: ${input2.registration.status}` : "status: (not in registry)";
+}
 function normalizeEnvironment(value) {
   const trimmed = value?.trim().toLowerCase();
   if (!trimmed || trimmed === "production" || trimmed === "prod") {
@@ -5402,7 +5408,7 @@ async function handleLanesShow(releaseId, options) {
             title: `Lane ${releaseId} (${environment}):`,
             lines: [
               `registered: ${payload.registered}`,
-              payload.lane ? `status: ${payload.lane.status}${payload.lane.active ? " (active)" : ""}` : "status: (not in registry)",
+              laneStatusLine(payload),
               `queue: ${payload.retireCheck.queue}`,
               `queued tasks: ${payload.retireCheck.queuedTasks}`,
               `non-terminal runs: ${payload.retireCheck.nonTerminalRuns}`,
@@ -5444,7 +5450,7 @@ async function handleReleasesActivate(releaseId, options) {
     {
       releaseId,
       environment,
-      ...options.schedulerBackend ? { schedulerBackend: options.schedulerBackend } : {}
+      schedulerBackend: options.schedulerBackend ?? "absurd"
     }
   );
   printCommandEnvelope(
@@ -5469,7 +5475,10 @@ function registerAdminCommands(program) {
   lanes.command("show <releaseId>").description("Show one lane and its retire-gate depth.").option("--environment <env>", "production (default) or preview").option("--json", "Emit JSON output. Also automatic when stdout is piped").action(handleLanesShow);
   lanes.command("retire-check <releaseId>").description("Check whether a lane is safe to retire (queue empty).").option("--environment <env>", "production (default) or preview").option("--json", "Emit JSON output. Also automatic when stdout is piped").action(handleLanesRetireCheck);
   const releases = admin.command("releases").description("Manage the active runtime release pointer.");
-  releases.command("activate <releaseId>").description("Flip the active runtime release to a prior registered lane.").option("--environment <env>", "production (default) or preview").option("--scheduler-backend <backend>", "absurd or workers_edge").option("--json", "Emit JSON output. Also automatic when stdout is piped").action(handleReleasesActivate);
+  releases.command("activate <releaseId>").description("Activate a prior registered Absurd release lane.").option("--environment <env>", "production (default) or preview").option(
+    "--scheduler-backend <backend>",
+    "compatibility flag: absurd only; workers_edge is disabled"
+  ).option("--json", "Emit JSON output. Also automatic when stdout is piped").action(handleReleasesActivate);
 }
 
 // src/cli/commands/auth.ts

package/dist/cli/index.mjs

@@ -610,10 +610,10 @@ var SDK_RELEASE = {
   // 0.1.175 ships loud `deepline enrich` empty-waterfall reporting.
   // 0.1.220 deprecates SDK CLI versions below 0.1.219 and updates them
   // automatically without blocking their current command.
-  version: "0.1.221",
+  version: "0.1.222",
   apiContract: "2026-06-dataset-handle-results-hard-cutover",
   supportPolicy: {
-    latest: "0.1.221",
+    latest: "0.1.222",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.219",
     commandMinimumSupported: [
@@ -5341,6 +5341,12 @@ function printCommandEnvelope(envelope, options = {}) {
 }
 
 // src/cli/commands/admin.ts
+function laneStatusLine(input2) {
+  if (input2.lane) {
+    return `status: ${input2.lane.status}${input2.lane.active ? " (active)" : ""}`;
+  }
+  return input2.registration ? `status: ${input2.registration.status}` : "status: (not in registry)";
+}
 function normalizeEnvironment(value) {
   const trimmed = value?.trim().toLowerCase();
   if (!trimmed || trimmed === "production" || trimmed === "prod") {
@@ -5393,7 +5399,7 @@ async function handleLanesShow(releaseId, options) {
             title: `Lane ${releaseId} (${environment}):`,
             lines: [
               `registered: ${payload.registered}`,
-              payload.lane ? `status: ${payload.lane.status}${payload.lane.active ? " (active)" : ""}` : "status: (not in registry)",
+              laneStatusLine(payload),
               `queue: ${payload.retireCheck.queue}`,
               `queued tasks: ${payload.retireCheck.queuedTasks}`,
               `non-terminal runs: ${payload.retireCheck.nonTerminalRuns}`,
@@ -5435,7 +5441,7 @@ async function handleReleasesActivate(releaseId, options) {
     {
       releaseId,
       environment,
-      ...options.schedulerBackend ? { schedulerBackend: options.schedulerBackend } : {}
+      schedulerBackend: options.schedulerBackend ?? "absurd"
     }
   );
   printCommandEnvelope(
@@ -5460,7 +5466,10 @@ function registerAdminCommands(program) {
   lanes.command("show <releaseId>").description("Show one lane and its retire-gate depth.").option("--environment <env>", "production (default) or preview").option("--json", "Emit JSON output. Also automatic when stdout is piped").action(handleLanesShow);
   lanes.command("retire-check <releaseId>").description("Check whether a lane is safe to retire (queue empty).").option("--environment <env>", "production (default) or preview").option("--json", "Emit JSON output. Also automatic when stdout is piped").action(handleLanesRetireCheck);
   const releases = admin.command("releases").description("Manage the active runtime release pointer.");
-  releases.command("activate <releaseId>").description("Flip the active runtime release to a prior registered lane.").option("--environment <env>", "production (default) or preview").option("--scheduler-backend <backend>", "absurd or workers_edge").option("--json", "Emit JSON output. Also automatic when stdout is piped").action(handleReleasesActivate);
+  releases.command("activate <releaseId>").description("Activate a prior registered Absurd release lane.").option("--environment <env>", "production (default) or preview").option(
+    "--scheduler-backend <backend>",
+    "compatibility flag: absurd only; workers_edge is disabled"
+  ).option("--json", "Emit JSON output. Also automatic when stdout is piped").action(handleReleasesActivate);
 }
 
 // src/cli/commands/auth.ts

package/dist/index.js

@@ -424,10 +424,10 @@ var SDK_RELEASE = {
   // 0.1.175 ships loud `deepline enrich` empty-waterfall reporting.
   // 0.1.220 deprecates SDK CLI versions below 0.1.219 and updates them
   // automatically without blocking their current command.
-  version: "0.1.221",
+  version: "0.1.222",
   apiContract: "2026-06-dataset-handle-results-hard-cutover",
   supportPolicy: {
-    latest: "0.1.221",
+    latest: "0.1.222",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.219",
     commandMinimumSupported: [

package/dist/index.mjs

@@ -354,10 +354,10 @@ var SDK_RELEASE = {
   // 0.1.175 ships loud `deepline enrich` empty-waterfall reporting.
   // 0.1.220 deprecates SDK CLI versions below 0.1.219 and updates them
   // automatically without blocking their current command.
-  version: "0.1.221",
+  version: "0.1.222",
   apiContract: "2026-06-dataset-handle-results-hard-cutover",
   supportPolicy: {
-    latest: "0.1.221",
+    latest: "0.1.222",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.219",
     commandMinimumSupported: [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepline",
-  "version": "0.1.221",
+  "version": "0.1.222",
   "description": "Deepline SDK + CLI — B2B data enrichment powered by durable cloud execution",
   "license": "MIT",
   "repository": {