deepline 0.3.200 → 0.3.201

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

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

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

@@ -1045,8 +1045,8 @@ export interface StopPlayRunResult {
 
 /**
  * Result of an actual workspace stop-all. `stopped` counts only runs whose
- * scheduler cancellation was confirmed; a run whose cancel failed stays active
- * and is counted in `failed`.
+ * scheduler cancellation was confirmed; queued requests are counted in
+ * `cancelling`, while requests that could not be queued count as `failed`.
  */
 export interface StopAllPlayRunsStopResult {
   stopped: number;

package/dist/bundling-sources/shared_libs/play-runtime/scheduler-backends/absurd-deadline-reconciliation.ts

@@ -1,4 +1,10 @@
-import { cancelPostgresSchedulerRun } from './postgres';
+import {
+  abandonUnstartedModalCancellationReservations,
+  cancelPostgresSchedulerRun,
+  enqueuePostgresSchedulerSandboxCleanupForRun,
+  hasPendingPostgresSchedulerSandboxCleanupForRun,
+  readPostgresSchedulerResult,
+} from './postgres';
 import type {
   PostgresSchedulerOptions,
   PostgresSchedulerQueryClient,
@@ -14,31 +20,100 @@ import { resolveRuntimeSchedulerSchemaEnv } from './runtime-scheduler-schema';
 
 /** Bound deadline reconciliation just like Absurd's own cancellation sweep. */
 export const ABSURD_CANCELLED_DEADLINE_RECONCILE_LIMIT = 100;
+const QUEUED_CANCELLATION_RECONCILE_LIMIT = 20;
 
 function quoteAbsurdTable(table: string): string {
   return `"${table.replaceAll('"', '""')}"`;
 }
 
-/**
- * Project a play task cancelled by Absurd into the scheduler's authoritative
- * run state. This covers both indexed `max_delay` cancellation and the manual
- * cancellation lane. Manual cancellation stamps `cancel_at` in the adapter so
- * existing Absurd v4 queues are discoverable without a schema cutover.
- *
- * The engine can cancel an overdue task before or after a worker claims its
- * handler. A cancelled task has no handler path left to write the normal
- * terminal state. This reconciler
- * closes that gap: `cancelPostgresSchedulerRun` atomically writes the runtime
- * terminal and its run-ledger outbox event, and is idempotent if a user cancel
- * or a racing worker already terminalized the run. The next claim/maintenance
- * pass invokes it after Absurd performs its bounded cancellation sweep.
- */
+async function finalizeCancelledRunAfterCleanup(input: {
+  client: PostgresSchedulerQueryClient;
+  runId: string;
+  reason: string;
+  schedulerSchema: string;
+  schedulerOptions?: Pick<PostgresSchedulerOptions, 'schema'>;
+  controlKey: string;
+}): Promise<'pending' | 'cancelled' | 'already_terminal'> {
+  await input.client.query('BEGIN');
+  try {
+    await input.client.query(
+      `SELECT set_config('lock_timeout', $1, true),
+              set_config('statement_timeout', $2, true)`,
+      [
+        `${RUNTIME_SCHEDULER_CANCEL_LOCK_TIMEOUT_MS}ms`,
+        `${RUNTIME_SCHEDULER_CANCEL_STATEMENT_TIMEOUT_MS}ms`,
+      ],
+    );
+    // Sandbox admission locks the run before reserving an operation; resource
+    // writers lock attempts. Hold both through the final cleanup check.
+    await input.client.query(
+      `SELECT run_id FROM ${input.schedulerSchema}.runs
+       WHERE run_id = $1 FOR UPDATE`,
+      [input.runId],
+    );
+    await input.client.query(
+      `SELECT attempt FROM ${input.schedulerSchema}.attempts
+       WHERE run_id = $1 FOR UPDATE`,
+      [input.runId],
+    );
+    await abandonUnstartedModalCancellationReservations(
+      input.client,
+      { runId: input.runId },
+      input.schedulerOptions,
+    );
+    await enqueuePostgresSchedulerSandboxCleanupForRun(
+      input.client,
+      { runId: input.runId },
+      input.schedulerOptions,
+    );
+    if (
+      await hasPendingPostgresSchedulerSandboxCleanupForRun(
+        input.client,
+        { runId: input.runId },
+        input.schedulerOptions,
+      )
+    ) {
+      await input.client.query('COMMIT');
+      return 'pending';
+    }
+    const cancelled = await cancelPostgresSchedulerRun(
+      input.client,
+      { runId: input.runId, reason: input.reason },
+      input.schedulerOptions,
+    );
+    if (
+      !cancelled &&
+      !(await readPostgresSchedulerResult(
+        input.client,
+        input.runId,
+        input.schedulerOptions,
+      ))
+    ) {
+      throw new Error(
+        `Cancellation did not terminalize scheduler run "${input.runId}".`,
+      );
+    }
+    await input.client.query(
+      `DELETE FROM ${input.schedulerSchema}.control WHERE key = $1`,
+      [input.controlKey],
+    );
+    await input.client.query('COMMIT');
+    return cancelled ? 'cancelled' : 'already_terminal';
+  } catch (error) {
+    await input.client.query('ROLLBACK').catch(() => undefined);
+    throw error;
+  }
+}
+
+/** Put legacy manual and deadline cancellations into the same durable queue
+ * as caller requests. A queued task is excluded from later scans, so one
+ * pending sandbox cannot hide other cancelled tasks behind the batch limit. */
 export async function reconcileAbsurdRuntimeCancellations(input: {
   client: PostgresSchedulerQueryClient;
   queue: string;
   schedulerOptions?: Pick<PostgresSchedulerOptions, 'schema'>;
   limit?: number;
-}): Promise<{ reconciled: number; skipped: number }> {
+}): Promise<{ queued: number }> {
   const requestedLimit = Math.floor(
     input.limit ?? ABSURD_CANCELLED_DEADLINE_RECONCILE_LIMIT,
   );
@@ -54,16 +129,21 @@ export async function reconcileAbsurdRuntimeCancellations(input: {
       resolveRuntimeSchedulerSchemaEnv() ||
       'runtime_scheduler',
   );
-  const cancelled = await input.client.query<{
-    run_id: string | null;
-    cancellation_kind: 'manual' | 'deadline';
-  }>(
+  const queued = await input.client.query<{ key: string }>(
     `
-      SELECT run.run_id,
-             CASE
-               WHEN task.cancellation ? 'manual' THEN 'manual'
-               ELSE 'deadline'
-             END AS cancellation_kind
+      INSERT INTO ${schedulerSchema}.control (key, value)
+      SELECT 'runtime_cancel:' || run.run_id,
+             jsonb_build_object(
+               'reason', CASE
+                 WHEN task.cancellation ? 'manual'
+                   THEN COALESCE(
+                     NULLIF(task.cancellation->>'reason', ''),
+                     'Run cancellation was requested by the caller.'
+                   )
+                 ELSE 'Run did not start within its configured scheduler queue deadline.'
+               END,
+               'requestedAt', clock_timestamp()
+             )
       FROM ${schedulerSchema}.runs AS run
       JOIN absurd.${taskTable} AS task
         ON task.task_id::text = run.absurd_task_id
@@ -78,57 +158,79 @@ export async function reconcileAbsurdRuntimeCancellations(input: {
             AND task.cancelled_at >= task.cancel_at
           )
         )
+        AND NOT EXISTS (
+          SELECT 1 FROM ${schedulerSchema}.control AS pending
+          WHERE pending.key = 'runtime_cancel:' || run.run_id
+        )
       ORDER BY task.cancelled_at ASC NULLS LAST, task.task_id ASC
       LIMIT $2
+      ON CONFLICT (key) DO NOTHING
+      RETURNING key
     `,
     [ABSURD_PLAY_RUN_TASK, limit],
   );
+  return { queued: queued.rows.length };
+}
 
+/** Drain caller-requested cancellations independently of their release lane. */
+export async function reconcileQueuedAbsurdRuntimeCancellations(input: {
+  client: PostgresSchedulerQueryClient;
+  schedulerOptions?: Pick<PostgresSchedulerOptions, 'schema'>;
+  limit?: number;
+}): Promise<{ reconciled: number; skipped: number }> {
+  const schedulerSchema = quoteAbsurdTable(
+    input.schedulerOptions?.schema?.trim() ||
+      resolveRuntimeSchedulerSchemaEnv() ||
+      'runtime_scheduler',
+  );
+  const requestedLimit = Math.floor(
+    input.limit ?? QUEUED_CANCELLATION_RECONCILE_LIMIT,
+  );
+  const limit = Number.isFinite(requestedLimit)
+    ? Math.max(1, Math.min(QUEUED_CANCELLATION_RECONCILE_LIMIT, requestedLimit))
+    : QUEUED_CANCELLATION_RECONCILE_LIMIT;
+  const queued = await input.client.query<{
+    key: string;
+    reason: string | null;
+  }>(
+    `WITH selected AS (
+       SELECT key FROM ${schedulerSchema}.control
+       WHERE starts_with(key, 'runtime_cancel:')
+       ORDER BY updated_at ASC, key ASC
+       LIMIT $1
+       FOR UPDATE SKIP LOCKED
+     )
+     UPDATE ${schedulerSchema}.control AS request
+     SET updated_at = clock_timestamp()
+     FROM selected
+     WHERE request.key = selected.key
+     RETURNING request.key, request.value->>'reason' AS reason`,
+    [limit],
+  );
   let reconciled = 0;
   let skipped = 0;
-  for (const row of cancelled.rows) {
-    const runId = row.run_id?.trim();
+  for (const row of queued.rows) {
+    const runId = row.key.slice('runtime_cancel:'.length);
     if (!runId) {
-      skipped += 1;
-      continue;
+      throw new Error(`Malformed runtime cancellation request "${row.key}".`);
     }
-    await input.client.query('BEGIN');
     try {
-      await input.client.query(
-        `SELECT set_config('lock_timeout', $1, true),
-                set_config('statement_timeout', $2, true)`,
-        [
-          `${RUNTIME_SCHEDULER_CANCEL_LOCK_TIMEOUT_MS}ms`,
-          `${RUNTIME_SCHEDULER_CANCEL_STATEMENT_TIMEOUT_MS}ms`,
-        ],
-      );
-      const didCancel = await cancelPostgresSchedulerRun(
-        input.client,
-        {
-          runId,
-          reason:
-            row.cancellation_kind === 'manual'
-              ? 'Run cancellation was requested by the caller.'
-              : 'Run did not start within its configured scheduler queue deadline.',
-        },
-        input.schedulerOptions,
-      );
-      await input.client.query('COMMIT');
-      if (didCancel) reconciled += 1;
+      const outcome = await finalizeCancelledRunAfterCleanup({
+        client: input.client,
+        runId,
+        reason: row.reason || 'Cancelled play run.',
+        schedulerSchema,
+        schedulerOptions: input.schedulerOptions,
+        controlKey: row.key,
+      });
+      if (outcome === 'cancelled') reconciled += 1;
       else skipped += 1;
     } catch (error) {
-      await input.client.query('ROLLBACK').catch(() => undefined);
-      // A worker-held lock is expected to be retried by the next lane sweep;
-      // never let one blocked cancellation stall the claim loop or create a
-      // second unbounded cancellation pile.
       if (
         isRuntimeSchedulerQueryCancellationError(error) ||
         isRuntimeSchedulerRetryableTransactionError(error)
       ) {
         skipped += 1;
-        // The hardened pool destroys a client after a statement timeout or a
-        // retryable transaction error. Do not issue the next candidate on that
-        // same socket; the next worker sweep acquires a fresh client.
         break;
       }
       throw error;

package/dist/bundling-sources/shared_libs/play-runtime/scheduler-backends/absurd-runtime-worker.ts

@@ -262,10 +262,13 @@ import { shouldTerminalizeSandboxCapacityRejection } from '../launch-source-poli
 import {
   ABSURD_CANCELLED_DEADLINE_RECONCILE_LIMIT,
   reconcileAbsurdRuntimeCancellations,
+  reconcileQueuedAbsurdRuntimeCancellations,
 } from './absurd-deadline-reconciliation';
 import {
   abandonRuntimeSandboxOperationReservation,
   bindRuntimeSandboxCapacityLease,
+  readReservedDaytonaCancellationOperation,
+  recordRecoveredDaytonaCancellationSandbox,
   reserveRuntimeSandboxOperation,
   runtimeSandboxCapacityAdmissionMode,
   RuntimeSandboxCapacityLimitError,
@@ -373,8 +376,8 @@ export const ABSURD_ADOPTED_LANE_POLL_INTERVAL_MS =
 const HEARTBEAT_THROTTLE_MS = (HEARTBEAT_CLAIM_TIMEOUT_SECONDS * 1000) / 3;
 const HEARTBEAT_TIMEOUT_RETRY_DELAY_MS = 1_000;
 /**
- * Sandbox deletion is best-effort cleanup after a durable terminal write. The
- * Daytona SDK may hang before its own delete timeout (for example while
+ * Sandbox deletion is a durable obligation and may precede a cancellation's
+ * terminal write. The Daytona SDK may hang before its own delete timeout (for example while
  * looking up an already-autostopped sandbox), so never let that external call
  * occupy an Absurd worker slot indefinitely.
  */
@@ -6644,6 +6647,75 @@ export async function reconcilePostgresSchedulerAmbiguousModalCreatesOnce(input:
   return { observed: intents.length, resourcesRecorded, resolvedAbsent };
 }
 
+async function reconcileReservedDaytonaCancellationOnce(input: {
+  runWithClient: AbsurdRuntimeWorkerDeps['runWithClient'];
+  environment: 'preview' | 'production';
+  schedulerOptions: Pick<PostgresSchedulerOptions, 'schema'>;
+}): Promise<void> {
+  const operation = await input.runWithClient((client) =>
+    readReservedDaytonaCancellationOperation(
+      client,
+      input.environment,
+      input.schedulerOptions,
+    ),
+  );
+  if (!operation) return;
+  const [{ Daytona }, { loadDaytonaRequiredConfig }] = await Promise.all([
+    import('@daytonaio/sdk'),
+    import('../daytona-runtime-config'),
+  ]);
+  const daytona = new Daytona(
+    loadDaytonaRequiredConfig({ environment: input.environment }).clientOptions,
+  );
+  const sandboxName = `dl-${operation.providerOperationToken}`;
+  let sandbox: Awaited<ReturnType<typeof daytona.get>>;
+  try {
+    sandbox = await deleteRuntimeSandboxBounded({
+      deleteRuntimeSandbox: (name) => daytona.get(name),
+      sandboxId: sandboxName,
+      timeoutMs: ABSURD_SANDBOX_GC_TIMEOUT_MS,
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (!/\b(?:sandbox )?not found\b|\b404\b/i.test(message)) throw error;
+    if (
+      Date.now() - operation.createdAtMs <
+      RUNTIME_RELIABILITY_POLICY.recovery.horizonMs
+    ) {
+      return;
+    }
+    await input.runWithClient((client) =>
+      abandonRuntimeSandboxOperationReservation(
+        client,
+        { operationKey: operation.operationKey },
+        input.schedulerOptions,
+      ),
+    );
+    return;
+  }
+  if (sandbox.labels?.operationKey !== operation.providerOperationToken) {
+    throw new Error(
+      `Daytona cancellation lookup ${sandboxName} lacks its exact operation label.`,
+    );
+  }
+  if (!sandbox.organizationId) {
+    throw new Error(
+      `Daytona cancellation lookup ${sandboxName} lacks its routing organization.`,
+    );
+  }
+  await input.runWithClient((client) =>
+    recordRecoveredDaytonaCancellationSandbox(
+      client,
+      {
+        operationKey: operation.operationKey,
+        sandboxId: sandbox.id,
+        routingDomain: sandbox.organizationId,
+      },
+      input.schedulerOptions,
+    ),
+  );
+}
+
 export async function runPostgresSchedulerSandboxCleanupController(input: {
   runWithClient: AbsurdRuntimeWorkerDeps['runWithClient'];
   deleteRuntimeSandbox: AbsurdRuntimeWorkerDeps['deleteRuntimeSandbox'];
@@ -6681,6 +6753,8 @@ export async function runPostgresSchedulerSandboxCleanupController(input: {
   const reportReconciliationPollFailure = createRateLimitedRuntimeLogger({
     log: (...args) => console.warn(...args),
   });
+  let reservedRecovery: Promise<void> | null = null;
+  let nextReservedRecoveryAt = 0;
 
   const startJob = (job: PostgresSchedulerSandboxCleanupJob): void => {
     const task = processPostgresSchedulerSandboxCleanupJob({
@@ -6726,6 +6800,37 @@ export async function runPostgresSchedulerSandboxCleanupController(input: {
   };
 
   while (!input.shouldStop()) {
+    if (
+      (!input.providers || input.providers.includes('daytona')) &&
+      !reservedRecovery &&
+      Date.now() >= nextReservedRecoveryAt
+    ) {
+      nextReservedRecoveryAt = Date.now() + 60_000;
+      const recovery = reconcileReservedDaytonaCancellationOnce(input)
+        .catch((error) => {
+          reportReconciliationPollFailure(
+            '[absurd-runtime.worker] daytona_cancellation_reservation_recovery_failed',
+            { error: error instanceof Error ? error.message : String(error) },
+          );
+        })
+        .finally(() => {
+          if (reservedRecovery === recovery) reservedRecovery = null;
+        });
+      reservedRecovery = recovery;
+    }
+    try {
+      await input.runWithClient((client) =>
+        reconcileQueuedAbsurdRuntimeCancellations({
+          client,
+          schedulerOptions: input.schedulerOptions,
+        }),
+      );
+    } catch (error) {
+      reportReconciliationPollFailure(
+        '[absurd-runtime.worker] cancellation_reconciliation_poll_failed',
+        { error: error instanceof Error ? error.message : String(error) },
+      );
+    }
     if (input.providers?.includes('modal')) {
       try {
         const reconciliation =
@@ -7082,9 +7187,9 @@ export async function startRuntimeWorkerHost(
         queue,
         schedulerOptions,
       });
-      if (cancellations.reconciled > 0 || cancellations.skipped > 0) {
+      if (cancellations.queued > 0) {
         reportCancellationProgress(
-          '[absurd-runtime.worker] cancellations_reconciled',
+          '[absurd-runtime.worker] cancellations_queued',
           {
             queue,
             releaseId,
@@ -7244,9 +7349,9 @@ export async function startRuntimeWorkerHost(
               queue: adoptedQueue,
               schedulerOptions,
             });
-            if (cancellations.reconciled > 0 || cancellations.skipped > 0) {
+            if (cancellations.queued > 0) {
               reportAdoptedCancellationProgress(
-                '[absurd-runtime.worker] cancellations_reconciled',
+                '[absurd-runtime.worker] cancellations_queued',
                 {
                   queue: adoptedQueue,
                   releaseId,

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

@@ -14,8 +14,8 @@
  *             Persist the absurd task id
  *             on the run row so a later cancel can target it.
  *   observe/result → reuse the postgres LISTEN/NOTIFY run handle.
- *   cancel  → one bounded transaction cancels the Absurd task and terminalizes
- *             the postgres scheduler run. Success means both states committed.
+ *   cancel  → commit the Absurd stop and a durable cancellation request;
+ *             the worker deletes sandboxes before the final run write.
  *   signal  → durable signal row (authoritative payload) + absurd emitEvent
  *             (the wakeup only; payload is re-read from the signal row).
  */
@@ -29,8 +29,6 @@ import {
   type PlaySchedulerSubmitInput,
 } from '../scheduler-backend';
 import {
-  cancelPostgresSchedulerRun,
-  postgresSchedulerCancellationOutboxLease,
   postgresSchedulerRunHandle,
   readPostgresSchedulerLaunch,
   readPostgresSchedulerAbsurdTaskId,
@@ -48,6 +46,8 @@ import {
   withRuntimeSchedulerClient,
   withRuntimeSchedulerTransaction,
 } from './postgres-pool';
+import { RUNTIME_SCHEDULER_CANCELLATION_PENDING_CODE } from '../scheduler-backend';
+import { resolveRuntimeSchedulerSchemaEnv } from './runtime-scheduler-schema';
 import { withRuntimeSchedulerSubmitAdmission } from './submit-admission';
 import {
   ABSURD_PLAY_RUN_MAX_ATTEMPTS,
@@ -200,7 +200,7 @@ function absurdRunHandle(input: {
   const runsQueue = absurdQueueNameForRelease(releaseId);
   const cancellationKey = `${poolOptions.url}::${effectiveOptions.schema ?? ''}::${input.runId}`;
 
-  const cancelAbsurdRunSynchronously = async (reason?: string) =>
+  const queueCancellation = async (reason?: string) =>
     withRuntimeSchedulerTransaction(
       poolOptions,
       {
@@ -208,9 +208,8 @@ function absurdRunHandle(input: {
         statementTimeoutMs: RUNTIME_SCHEDULER_CANCEL_STATEMENT_TIMEOUT_MS,
       },
       async (client) => {
-        // Resolve the immutable release lane inside the same checkout and
-        // transaction that performs cancellation. The stop endpoint therefore
-        // has no preliminary lane lookup that can succeed or fail separately.
+        // Resolve the immutable release lane in the transaction that records
+        // the request. A failed final run write cannot roll this marker back.
         const launch = await readPostgresSchedulerLaunch(
           client,
           input.runId,
@@ -231,67 +230,73 @@ function absurdRunHandle(input: {
           input.runId,
           effectiveOptions,
         );
+        if (
+          await readPostgresSchedulerResult(
+            client,
+            input.runId,
+            effectiveOptions,
+          )
+        ) {
+          return false;
+        }
         if (taskId) {
-          const engineTaskCancelled = await cancelAbsurdTaskIfPresent(client, {
+          const engineTaskPresent = await cancelAbsurdTaskIfPresent(client, {
             queue: cancellationQueue,
             taskId,
             runId: input.runId,
           });
-          // Older v4 Absurd functions do not materialize a manual cancellation
-          // deadline or reason. Stamp both in the adapter so existing queues
-          // participate in the same durable reconciliation lane without a
-          // schema cutover. The explicit marker keeps a user cancel distinct
-          // from a task cancelled by its configured max_delay sweep.
-          if (engineTaskCancelled) {
+          if (engineTaskPresent) {
+            // Older workers only reconcile `manual` or `max_delay`. This
+            // marker is diagnostic; the control row is the cross-lane queue.
             await client.query(
               `UPDATE absurd.${quotePostgresIdentifier(`t_${cancellationQueue}`)}
                 SET cancel_at = COALESCE(cancel_at, clock_timestamp()),
                     cancellation = COALESCE(cancellation, '{}'::jsonb)
-                      || jsonb_build_object('manual', true)
-              WHERE task_id = $1::uuid
-                AND state = 'cancelled'`,
+                      || jsonb_build_object('sandboxFirst', true)
+              WHERE task_id = $1::uuid`,
               [taskId],
             );
           }
         }
-        const cancelled = await cancelPostgresSchedulerRun(
-          client,
-          {
-            runId: input.runId,
-            reason,
-            outboxLease: postgresSchedulerCancellationOutboxLease(input.runId),
-          },
-          effectiveOptions,
+        const schedulerSchema = quotePostgresIdentifier(
+          effectiveOptions.schema?.trim() ||
+            resolveRuntimeSchedulerSchemaEnv() ||
+            'runtime_scheduler',
         );
-        // The update returning a row is proof that this transaction wrote the
-        // terminal state and outbox event. Only the idempotent retry/race path
-        // needs one read to prove another terminal writer already won.
-        if (!cancelled) {
-          const terminal = await readPostgresSchedulerResult(
-            client,
-            input.runId,
-            effectiveOptions,
-          );
-          if (!terminal) {
-            throw new Error(
-              `Cancellation did not terminalize scheduler run "${input.runId}".`,
-            );
-          }
-        }
+        await client.query(
+          `INSERT INTO ${schedulerSchema}.control (key, value)
+           VALUES ($1, jsonb_build_object(
+             'reason', left($2::text, 4000),
+             'requestedAt', clock_timestamp()
+           ))
+           ON CONFLICT (key) DO NOTHING`,
+          [
+            `runtime_cancel:${input.runId}`,
+            reason?.trim() || 'Cancelled play run.',
+          ],
+        );
+        return true;
       },
       {
         runId: input.runId,
-        phase: 'cancel_run_synchronously',
+        phase: 'queue_run_cancellation',
         priority: 'critical',
       },
+      { maxAttempts: 1 },
     );
 
   const requestCancellation = async (reason?: string) => {
     await runCancellationSingleFlight(cancellationKey, async () => {
-      // Engine cancellation and the scheduler terminal write commit together.
-      // A timeout rolls both back, so returning means the run is terminal and
-      // throwing means the caller can safely retry one unchanged operation.
-      await cancelAbsurdRunSynchronously(reason);
+      const queued = await queueCancellation(reason);
+      if (queued) {
+        const error = new Error(
+          `Cancellation queued for ${input.runId}; sandbox cleanup and final run update are pending.`,
+        );
+        Object.assign(error, {
+          code: RUNTIME_SCHEDULER_CANCELLATION_PENDING_CODE,
+        });
+        throw error;
+      }
     });
   };
 

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

@@ -8774,13 +8774,29 @@ export async function resolvePostgresSchedulerAmbiguousModalCreateIntentFromProv
 ): Promise<boolean> {
   const resolved = await client.query<{ run_id: string }>(
     `
-      UPDATE ${tableName('ambiguous_modal_creates', options)}
-      SET status = 'resolved', resolved_at = clock_timestamp()
-      WHERE run_id = $1
-        AND attempt = $2
-        AND modal_app_id = $3
-        AND status = 'pending'
-      RETURNING run_id
+      WITH resolved AS (
+        UPDATE ${tableName('ambiguous_modal_creates', options)}
+        SET status = 'resolved', resolved_at = clock_timestamp()
+        WHERE run_id = $1
+          AND attempt = $2
+          AND modal_app_id = $3
+          AND status = 'pending'
+        RETURNING run_id, sandbox_capacity_lease_id
+      ), abandoned AS (
+        UPDATE ${tableName('runtime_sandbox_operations', options)} AS operation
+        SET state = 'abandoned', updated_at = clock_timestamp()
+        FROM resolved
+        WHERE operation.operation_key = resolved.sandbox_capacity_lease_id
+          AND operation.state = 'reserved'
+        RETURNING operation.operation_key
+      ), released AS (
+        UPDATE ${tableName('runtime_sandbox_capacity_leases', options)} AS lease
+        SET released_at = clock_timestamp()
+        FROM abandoned
+        WHERE lease.lease_id = abandoned.operation_key
+          AND lease.released_at IS NULL
+      )
+      SELECT run_id FROM resolved
     `,
     [input.runId, input.attempt, input.modalAppId],
   );
@@ -10587,6 +10603,131 @@ export async function enqueuePostgresSchedulerSandboxCleanupForAttempt(
   return enqueued.rows.length;
 }
 
+/** Queue every known sandbox before a requested cancellation can terminalize. */
+export async function enqueuePostgresSchedulerSandboxCleanupForRun(
+  client: PostgresSchedulerQueryClient,
+  input: { runId: string },
+  options?: Pick<PostgresSchedulerOptions, 'schema'>,
+): Promise<void> {
+  await client.query(
+    `
+      INSERT INTO ${tableName('sandbox_cleanup_jobs_v2', options)} (
+        provider, sandbox_id, run_id, attempt, environment, routing_domain
+      )
+      SELECT DISTINCT
+        CASE resource->>'kind'
+          WHEN 'modal_sandbox' THEN 'modal'
+          ELSE 'daytona'
+        END,
+        resource->>'sandboxId',
+        attempt.run_id,
+        attempt.attempt,
+        COALESCE(
+          NULLIF(resource->>'runtimeEnvironment', ''),
+          NULLIF(resource->>'daytonaEnvironment', ''),
+          'production'
+        ),
+        CASE resource->>'kind'
+          WHEN 'modal_sandbox' THEN NULLIF(resource->>'modalAppId', '')
+          ELSE NULLIF(resource->>'daytonaOrganizationId', '')
+        END
+      FROM ${tableName('attempts', options)} AS attempt
+      CROSS JOIN LATERAL jsonb_array_elements(
+        CASE
+          WHEN jsonb_typeof(attempt.resource_json) = 'array'
+            THEN attempt.resource_json
+          ELSE jsonb_build_array(attempt.resource_json)
+        END
+      ) AS resource
+      WHERE attempt.run_id = $1
+        AND attempt.resource_json IS NOT NULL
+        AND resource->>'kind' IN ('daytona_sandbox', 'modal_sandbox')
+        AND NULLIF(resource->>'sandboxId', '') IS NOT NULL
+      UNION ALL
+      SELECT operation.provider, operation.sandbox_id, operation.run_id,
+             operation.attempt, operation.environment, operation.routing_domain
+      FROM ${tableName('runtime_sandbox_operations', options)} AS operation
+      WHERE operation.run_id = $1
+        AND operation.state IN ('live', 'deleting')
+        AND operation.sandbox_id IS NOT NULL
+      ON CONFLICT (provider, sandbox_id, routing_domain_key) DO NOTHING
+    `,
+    [input.runId],
+  );
+}
+
+/** Modal cannot create without a durable intent; an old reservation with no
+ * pending selector or recorded resource is safe to release after recovery time. */
+export async function abandonUnstartedModalCancellationReservations(
+  client: PostgresSchedulerQueryClient,
+  input: { runId: string },
+  options?: Pick<PostgresSchedulerOptions, 'schema'>,
+): Promise<void> {
+  await client.query(
+    `WITH abandoned AS (
+       UPDATE ${tableName('runtime_sandbox_operations', options)} AS operation
+       SET state = 'abandoned', updated_at = clock_timestamp()
+       WHERE operation.run_id = $1
+         AND operation.provider = 'modal'
+         AND operation.state = 'reserved'
+         AND operation.created_at <= clock_timestamp()
+           - ($2::double precision * interval '1 millisecond')
+         AND NOT EXISTS (
+           SELECT 1 FROM ${tableName('ambiguous_modal_creates', options)} AS intent
+           WHERE intent.sandbox_capacity_lease_id = operation.operation_key
+             AND intent.status = 'pending'
+         )
+         AND NOT EXISTS (
+           SELECT 1 FROM ${tableName('attempts', options)} AS attempt
+           CROSS JOIN LATERAL jsonb_array_elements(
+             CASE
+               WHEN jsonb_typeof(attempt.resource_json) = 'array'
+                 THEN attempt.resource_json
+               WHEN attempt.resource_json IS NULL THEN '[]'::jsonb
+               ELSE jsonb_build_array(attempt.resource_json)
+             END
+           ) AS resource
+           WHERE attempt.run_id = operation.run_id
+             AND resource->>'sandboxCapacityLeaseId' = operation.operation_key
+         )
+       RETURNING operation.operation_key
+     )
+     UPDATE ${tableName('runtime_sandbox_capacity_leases', options)} AS lease
+     SET released_at = clock_timestamp()
+     FROM abandoned
+     WHERE lease.lease_id = abandoned.operation_key
+       AND lease.released_at IS NULL`,
+    [input.runId, RUNTIME_RELIABILITY_POLICY.recovery.horizonMs],
+  );
+}
+
+/** A reserved create or unconfirmed deletion keeps cancellation pending. */
+export async function hasPendingPostgresSchedulerSandboxCleanupForRun(
+  client: PostgresSchedulerQueryClient,
+  input: { runId: string },
+  options?: Pick<PostgresSchedulerOptions, 'schema'>,
+): Promise<boolean> {
+  const pending = await client.query<{ pending: boolean }>(
+    `
+      SELECT EXISTS (
+        SELECT 1
+        FROM ${tableName('sandbox_cleanup_jobs_v2', options)}
+        WHERE run_id = $1 AND status <> 'deleted'
+      ) OR EXISTS (
+        SELECT 1
+        FROM ${tableName('runtime_sandbox_operations', options)}
+        WHERE run_id = $1 AND state = 'reserved'
+      ) OR EXISTS (
+        SELECT 1
+        FROM ${tableName('ambiguous_modal_creates', options)}
+        WHERE run_id = $1 AND status = 'pending'
+      ) AS pending
+    `,
+    [input.runId],
+  );
+  return pending.rows[0]?.pending ?? true;
+}
+
 export async function claimPostgresSchedulerSandboxCleanupJobs(
   client: PostgresSchedulerQueryClient,
   input: {
@@ -12278,7 +12419,26 @@ export async function cancelPostgresSchedulerRun(
                     WHEN elem->>'kind' IN ('daytona_sandbox', 'modal_sandbox')
                      AND (elem->'billingEndedAt' IS NULL OR elem->'billingEndedAt' = 'null'::jsonb)
                     THEN elem || jsonb_build_object(
-                      'billingEndedAt', extract(epoch FROM clock_timestamp()) * 1000,
+                      'billingEndedAt', COALESCE(
+                        (
+                          SELECT extract(epoch FROM cleanup.deleted_at) * 1000
+                          FROM ${tableName('sandbox_cleanup_jobs_v2', options)} AS cleanup
+                          WHERE cleanup.provider = CASE elem->>'kind'
+                                  WHEN 'modal_sandbox' THEN 'modal'
+                                  ELSE 'daytona'
+                                END
+                            AND cleanup.sandbox_id = elem->>'sandboxId'
+                            AND cleanup.routing_domain_key = COALESCE(
+                                  CASE elem->>'kind'
+                                    WHEN 'modal_sandbox' THEN NULLIF(elem->>'modalAppId', '')
+                                    ELSE NULLIF(elem->>'daytonaOrganizationId', '')
+                                  END,
+                                  ''
+                                )
+                            AND cleanup.status = 'deleted'
+                        ),
+                        extract(epoch FROM clock_timestamp()) * 1000
+                      ),
                       'terminalAt', extract(epoch FROM clock_timestamp()) * 1000,
                       'terminalReason', 'cancelled'
                     )

package/dist/bundling-sources/shared_libs/play-runtime/scheduler-backends/runtime-sandbox-capacity.ts

@@ -64,6 +64,7 @@ function schemaTables(options?: Pick<PostgresSchedulerOptions, 'schema'>) {
     leases: `${schema}."runtime_sandbox_capacity_leases"`,
     operations: `${schema}."runtime_sandbox_operations"`,
     cleanup: `${schema}."sandbox_cleanup_jobs_v2"`,
+    runs: `${schema}."runs"`,
   };
 }
 
@@ -266,7 +267,7 @@ export async function reserveRuntimeSandboxCapacityLease(
 > {
   const orgId = assertId(input.orgId, 'orgId');
   const runId = assertId(input.runId, 'runId');
-  const { cache, leases, operations } = schemaTables(options);
+  const { cache, leases, operations, runs } = schemaTables(options);
   // This is deliberately a soft admission check: concurrent workers may both
   // observe space and insert. Avoid locks and long transactions; the provider
   // has its own global safety cap and the 50-minute lease bounds crashes.
@@ -469,13 +470,21 @@ export async function reserveRuntimeSandboxCapacityLease(
   }
   await client.query(
     `
-      WITH reserved_lease AS (
+      WITH active_run AS MATERIALIZED (
+        SELECT run_id FROM ${runs}
+        WHERE run_id = $3 AND status IN ('queued', 'running', 'waiting')
+          AND NOT EXISTS (
+            SELECT 1 FROM ${quoteIdent(options?.schema ?? 'runtime_scheduler')}."control"
+            WHERE key = 'runtime_cancel:' || $3::text
+          )
+        FOR UPDATE
+      ), reserved_lease AS (
         INSERT INTO ${leases} (
           lease_id, org_id, run_id, provider, expires_at
-        ) VALUES (
-          $1, $2, $3, $4,
-          clock_timestamp() + ($5::integer * interval '1 millisecond')
         )
+        SELECT $1, $2, $3, $4,
+               clock_timestamp() + ($5::integer * interval '1 millisecond')
+        WHERE $6::integer IS NULL OR EXISTS (SELECT 1 FROM active_run)
         ON CONFLICT (lease_id) DO NOTHING
         RETURNING lease_id
       )
@@ -726,6 +735,125 @@ export async function abandonRuntimeSandboxOperationReservation(
   return result.rows.length === 1;
 }
 
+export async function readReservedDaytonaCancellationOperation(
+  client: PostgresSchedulerQueryClient,
+  environment: 'preview' | 'production',
+  options?: Pick<PostgresSchedulerOptions, 'schema'>,
+): Promise<{
+  operationKey: string;
+  providerOperationToken: string;
+  createdAtMs: number;
+} | null> {
+  const { operations } = schemaTables(options);
+  const schema = quoteIdent(options?.schema ?? 'runtime_scheduler');
+  const rows = await client.query<{
+    operation_key: string;
+    provider_operation_token: string | null;
+    created_at_ms: number;
+  }>(
+    `WITH candidate AS (
+       SELECT operation.operation_key
+       FROM ${operations} AS operation
+       JOIN ${schema}."control" AS request
+         ON request.key = 'runtime_cancel:' || operation.run_id
+       WHERE operation.provider = 'daytona'
+         AND operation.environment = $1
+         AND operation.state = 'reserved'
+       ORDER BY operation.updated_at ASC, operation.operation_key ASC
+       LIMIT 1
+       FOR UPDATE OF operation SKIP LOCKED
+     )
+     UPDATE ${operations} AS operation
+     SET updated_at = clock_timestamp()
+     FROM candidate
+     WHERE operation.operation_key = candidate.operation_key
+     RETURNING operation.operation_key, operation.provider_operation_token,
+               floor(extract(epoch FROM operation.created_at) * 1000)::bigint AS created_at_ms`,
+    [environment],
+  );
+  const row = rows.rows[0];
+  if (!row) return null;
+  if (!row.provider_operation_token) {
+    throw new Error(
+      `Reserved Daytona cancellation operation ${row.operation_key} lacks its provider token.`,
+    );
+  }
+  return {
+    operationKey: row.operation_key,
+    providerOperationToken: row.provider_operation_token,
+    createdAtMs: Number(row.created_at_ms),
+  };
+}
+
+export async function recordRecoveredDaytonaCancellationSandbox(
+  client: PostgresSchedulerQueryClient,
+  input: { operationKey: string; sandboxId: string; routingDomain: string },
+  options?: Pick<PostgresSchedulerOptions, 'schema'>,
+): Promise<boolean> {
+  const { operations, leases, cleanup } = schemaTables(options);
+  const schema = quoteIdent(options?.schema ?? 'runtime_scheduler');
+  const recorded = await client.query<{ operation_key: string }>(
+    `WITH promoted AS (
+       UPDATE ${operations} AS operation
+       SET state = 'deleting',
+           sandbox_id = $2,
+           routing_domain = $3,
+           provider_created_at = clock_timestamp(),
+           updated_at = clock_timestamp()
+       WHERE operation.operation_key = $1
+         AND operation.provider = 'daytona'
+         AND operation.state = 'reserved'
+       RETURNING operation.operation_key, operation.run_id, operation.attempt,
+                 operation.environment, operation.created_at
+     ), resource AS (
+       SELECT promoted.*,
+              jsonb_build_object(
+                'kind', 'daytona_sandbox',
+                'sandboxId', $2::text,
+                'runtimeEnvironment', promoted.environment,
+                'daytonaOrganizationId', $3::text,
+                'billingStartedAt', extract(epoch FROM promoted.created_at) * 1000,
+                'sandboxCapacityLeaseId', promoted.operation_key,
+                'lateAcquired', true
+              ) AS value
+       FROM promoted
+     ), recorded_attempt AS (
+       UPDATE ${schema}."attempts" AS attempt
+       SET resource_json = CASE
+             WHEN attempt.resource_json IS NULL THEN jsonb_build_array(resource.value)
+             WHEN jsonb_typeof(attempt.resource_json) = 'array'
+               THEN attempt.resource_json || jsonb_build_array(resource.value)
+             ELSE jsonb_build_array(attempt.resource_json, resource.value)
+           END,
+           updated_at = clock_timestamp()
+       FROM resource
+       WHERE attempt.run_id = resource.run_id
+         AND attempt.attempt = resource.attempt
+       RETURNING attempt.run_id
+     ), bound AS (
+       UPDATE ${leases} AS lease
+       SET sandbox_id = $2, routing_domain = $3
+       FROM promoted
+       WHERE lease.lease_id = promoted.operation_key
+         AND lease.released_at IS NULL
+       RETURNING lease.lease_id
+     ), queued AS (
+       INSERT INTO ${cleanup} (
+         provider, sandbox_id, run_id, attempt, environment, routing_domain
+       )
+       SELECT 'daytona', $2, promoted.run_id, promoted.attempt,
+              promoted.environment, $3
+       FROM promoted
+       ON CONFLICT (provider, sandbox_id, routing_domain_key) DO NOTHING
+     )
+     SELECT promoted.operation_key FROM promoted
+     JOIN recorded_attempt ON recorded_attempt.run_id = promoted.run_id
+     JOIN bound ON bound.lease_id = promoted.operation_key`,
+    [input.operationKey, input.sandboxId, input.routingDomain],
+  );
+  return recorded.rows.length === 1;
+}
+
 /** Release only after the provider confirms deletion (or already absent). */
 export async function releaseRuntimeSandboxCapacityLeaseForSandbox(
   client: PostgresSchedulerQueryClient,

package/dist/cli/index.js

@@ -3051,7 +3051,7 @@ var SDK_RELEASE = {
   // getters keep their established compatibility behavior.
   // 0.3.1 deprecated the legacy `deepline enrich` command in favor of Plays.
   // 0.3.90 is the first deliberately versioned SDK release for API v3.
-  version: "0.3.200",
+  version: "0.3.201",
   updateSummary: "Play grep now returns concise results with the matched fields and terms. Automatic CLI updates are enabled by default; use `deepline settings autoupdate off` to opt out, `deepline settings autoupdate on` to re-enable updates, or `deepline settings autoupdate pin <version>` to hold an exact release.",
   packageCapabilities: {
     updatePreferences: 1
@@ -29004,6 +29004,26 @@ async function handleRunStop(args) {
   }
   const client2 = new DeeplineClient();
   const result = await client2.runs.stop(runId, { reason });
+  if (result.cancelling === true) {
+    printCommandEnvelope(
+      {
+        ...result,
+        render: {
+          sections: [
+            {
+              title: "run stop",
+              lines: [
+                `Cancellation queued for ${result.runId || runId}; sandbox cleanup is pending`,
+                `inspect: deepline runs get ${runId} --full --json`
+              ]
+            }
+          ]
+        }
+      },
+      { json: argsWantJson(args) }
+    );
+    return 0;
+  }
   const stopNotConfirmed = result.stopped === false || result.staleSchedulerState === true;
   if (stopNotConfirmed) {
     const detail = typeof result.error === "string" && result.error.trim() ? result.error.trim() : result.staleSchedulerState === true ? "scheduler state for the run is stale" : "the server did not confirm the stop";
@@ -29118,6 +29138,7 @@ async function handleRunStopAll(args) {
   const result = await client2.runs.stopAll({ reason });
   const lines = [
     `Stopped ${result.stopped} active run${result.stopped === 1 ? "" : "s"}`,
+    ...result.cancelling ? [`cancellation queued: ${result.cancelling}`] : [],
     ...result.partial ? ["partial: active runs may remain; rerun stop-all"] : [],
     ...result.failed > 0 ? [`failed stops: ${result.failed}`] : [],
     ...result.skipped > 0 ? [`skipped: ${result.skipped}`] : []

package/dist/cli/index.mjs

@@ -3046,7 +3046,7 @@ var SDK_RELEASE = {
   // getters keep their established compatibility behavior.
   // 0.3.1 deprecated the legacy `deepline enrich` command in favor of Plays.
   // 0.3.90 is the first deliberately versioned SDK release for API v3.
-  version: "0.3.200",
+  version: "0.3.201",
   updateSummary: "Play grep now returns concise results with the matched fields and terms. Automatic CLI updates are enabled by default; use `deepline settings autoupdate off` to opt out, `deepline settings autoupdate on` to re-enable updates, or `deepline settings autoupdate pin <version>` to hold an exact release.",
   packageCapabilities: {
     updatePreferences: 1
@@ -29076,6 +29076,26 @@ async function handleRunStop(args) {
   }
   const client2 = new DeeplineClient();
   const result = await client2.runs.stop(runId, { reason });
+  if (result.cancelling === true) {
+    printCommandEnvelope(
+      {
+        ...result,
+        render: {
+          sections: [
+            {
+              title: "run stop",
+              lines: [
+                `Cancellation queued for ${result.runId || runId}; sandbox cleanup is pending`,
+                `inspect: deepline runs get ${runId} --full --json`
+              ]
+            }
+          ]
+        }
+      },
+      { json: argsWantJson(args) }
+    );
+    return 0;
+  }
   const stopNotConfirmed = result.stopped === false || result.staleSchedulerState === true;
   if (stopNotConfirmed) {
     const detail = typeof result.error === "string" && result.error.trim() ? result.error.trim() : result.staleSchedulerState === true ? "scheduler state for the run is stale" : "the server did not confirm the stop";
@@ -29190,6 +29210,7 @@ async function handleRunStopAll(args) {
   const result = await client2.runs.stopAll({ reason });
   const lines = [
     `Stopped ${result.stopped} active run${result.stopped === 1 ? "" : "s"}`,
+    ...result.cancelling ? [`cancellation queued: ${result.cancelling}`] : [],
     ...result.partial ? ["partial: active runs may remain; rerun stop-all"] : [],
     ...result.failed > 0 ? [`failed stops: ${result.failed}`] : [],
     ...result.skipped > 0 ? [`skipped: ${result.skipped}`] : []

package/dist/index.d.mts

@@ -1936,8 +1936,8 @@ interface StopPlayRunResult {
 }
 /**
  * Result of an actual workspace stop-all. `stopped` counts only runs whose
- * scheduler cancellation was confirmed; a run whose cancel failed stays active
- * and is counted in `failed`.
+ * scheduler cancellation was confirmed; queued requests are counted in
+ * `cancelling`, while requests that could not be queued count as `failed`.
  */
 interface StopAllPlayRunsStopResult {
     stopped: number;

package/dist/index.d.ts

@@ -1936,8 +1936,8 @@ interface StopPlayRunResult {
 }
 /**
  * Result of an actual workspace stop-all. `stopped` counts only runs whose
- * scheduler cancellation was confirmed; a run whose cancel failed stays active
- * and is counted in `failed`.
+ * scheduler cancellation was confirmed; queued requests are counted in
+ * `cancelling`, while requests that could not be queued count as `failed`.
  */
 interface StopAllPlayRunsStopResult {
     stopped: number;

package/dist/index.js

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

package/dist/index.mjs

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

package/dist/release.d.mts

@@ -149,7 +149,7 @@ type SdkRelease = {
     supportPolicy: SdkSupportPolicy;
 };
 declare const SDK_RELEASE: {
-    readonly version: "0.3.200";
+    readonly version: "0.3.201";
     readonly updateSummary: "Play grep now returns concise results with the matched fields and terms. Automatic CLI updates are enabled by default; use `deepline settings autoupdate off` to opt out, `deepline settings autoupdate on` to re-enable updates, or `deepline settings autoupdate pin <version>` to hold an exact release.";
     readonly packageCapabilities: {
         readonly updatePreferences: 1;

package/dist/release.d.ts

@@ -149,7 +149,7 @@ type SdkRelease = {
     supportPolicy: SdkSupportPolicy;
 };
 declare const SDK_RELEASE: {
-    readonly version: "0.3.200";
+    readonly version: "0.3.201";
     readonly updateSummary: "Play grep now returns concise results with the matched fields and terms. Automatic CLI updates are enabled by default; use `deepline settings autoupdate off` to opt out, `deepline settings autoupdate on` to re-enable updates, or `deepline settings autoupdate pin <version>` to hold an exact release.";
     readonly packageCapabilities: {
         readonly updatePreferences: 1;

package/dist/release.js

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

package/dist/release.mjs

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

package/package.json

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