deepline 0.3.175 → 0.3.176

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.175',
+  version: '0.3.176',
   updateSummary:
     'Play grep now returns concise results with the matched fields and terms. Automatic CLI updates are enabled by default; use `deepline settings autoupdate off` to opt out, `deepline settings autoupdate on` to re-enable updates, or `deepline settings autoupdate pin <version>` to hold an exact release.',
   packageCapabilities: {

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

@@ -14,33 +14,27 @@
  *             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  → durable Absurd cancellation lane + bounded postgres terminal
- *             projection (with worker reconciliation when locks are busy).
+ *   cancel  → one bounded transaction cancels the Absurd task and terminalizes
+ *             the postgres scheduler run. Success means both states committed.
  *   signal  → durable signal row (authoritative payload) + absurd emitEvent
  *             (the wakeup only; payload is re-read from the signal row).
  */
 import { recordPerfTrace } from '../perf-trace';
 import { CTX_RUN_PLAY_INLINE_ONLY } from '../child-execution-strategy';
 import { PLAY_ADMISSION_MAX_ACTIVE_LIFECYCLES } from '../admission-transport-policy';
-import {
-  defaultRuntimeSandboxReconciliation,
-  runtimeSandboxDeleteSucceeded,
-  runtimeSandboxRefIdentityKey,
-  runtimeSandboxRefFromResource,
-  type RuntimeSandboxRef,
-} from '../runner-backends/runtime-sandbox-reconciliation';
 import {
   PLAY_SCHEDULER_BACKENDS,
-  RUNTIME_SCHEDULER_CANCELLATION_PENDING_CODE,
   type PlaySchedulerBackend,
   type PlaySchedulerRunHandle,
   type PlaySchedulerSubmitInput,
 } from '../scheduler-backend';
 import {
+  cancelPostgresSchedulerRun,
+  postgresSchedulerCancellationOutboxLease,
   postgresSchedulerRunHandle,
   readPostgresSchedulerLaunch,
   readPostgresSchedulerAbsurdTaskId,
-  readPostgresSchedulerRuntimeResourcesForRun,
+  readPostgresSchedulerResult,
   recordPostgresSchedulerSignal,
 } from './postgres';
 import {
@@ -57,7 +51,6 @@ import { withRuntimeSchedulerSubmitAdmission } from './submit-admission';
 import {
   ABSURD_PLAY_RUN_MAX_ATTEMPTS,
   ABSURD_PLAY_RUN_RETRY_STRATEGY,
-  ABSURD_DAYTONA_SANDBOX_CLEANUP_TASK,
   absurdIntegrationEventName,
   absurdQueueNameForRelease,
   absurdReleaseIdForLaunch,
@@ -67,7 +60,6 @@ import {
   normalizeAbsurdSchedulerOptions,
   resolveAbsurdPoolOptions,
   serverlessAdmissionSubmitMaxActive,
-  type AbsurdDaytonaSandboxCleanupTaskParams,
   type AbsurdSchedulerOptions,
 } from './absurd-shared';
 
@@ -162,168 +154,98 @@ function absurdRunHandle(input: {
   const runsQueue = absurdQueueNameForRelease(releaseId);
   const cancellationKey = `${poolOptions.url}::${effectiveOptions.schema ?? ''}::${input.runId}`;
 
-  const cancelAbsurdTask = async () => {
-    const taskId = await withRuntimeSchedulerClient(poolOptions, (client) =>
-      readPostgresSchedulerAbsurdTaskId(client, input.runId, effectiveOptions),
-    );
-    if (!taskId) return;
-    // Keep cancellation on the same bounded control-plane contract as the
-    // scheduler terminal write. This is a durable lane transition, not an
-    // unbounded best-effort query which can pile up behind a worker lock.
-    await withRuntimeSchedulerTransaction(
+  const cancelAbsurdRunSynchronously = async (reason?: string) =>
+    withRuntimeSchedulerTransaction(
       poolOptions,
       {
         lockTimeoutMs: RUNTIME_SCHEDULER_CANCEL_LOCK_TIMEOUT_MS,
         statementTimeoutMs: RUNTIME_SCHEDULER_CANCEL_STATEMENT_TIMEOUT_MS,
       },
       async (client) => {
-        await client.query(`SELECT absurd.cancel_task($1, $2::uuid)`, [
-          runsQueue,
-          taskId,
-        ]);
-        // 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.
-        await client.query(
-          `UPDATE absurd.${quotePostgresIdentifier(`t_${runsQueue}`)}
+        // 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.
+        const launch = await readPostgresSchedulerLaunch(
+          client,
+          input.runId,
+          effectiveOptions,
+          { caller: 'play_run_control' },
+        );
+        if (!launch) {
+          throw new Error(
+            `Cannot cancel play run "${input.runId}": scheduler launch is missing.`,
+          );
+        }
+        const cancellationReleaseId = absurdReleaseIdForLaunch(launch);
+        const cancellationQueue = absurdQueueNameForRelease(
+          cancellationReleaseId,
+        );
+        const taskId = await readPostgresSchedulerAbsurdTaskId(
+          client,
+          input.runId,
+          effectiveOptions,
+        );
+        if (taskId) {
+          await client.query(`SELECT absurd.cancel_task($1, $2::uuid)`, [
+            cancellationQueue,
+            taskId,
+          ]);
+          // 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.
+          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'`,
-          [taskId],
+            [taskId],
+          );
+        }
+        const cancelled = await cancelPostgresSchedulerRun(
+          client,
+          {
+            runId: input.runId,
+            reason,
+            outboxLease: postgresSchedulerCancellationOutboxLease(input.runId),
+          },
+          effectiveOptions,
         );
+        // 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}".`,
+            );
+          }
+        }
       },
       {
         runId: input.runId,
-        phase: 'cancel_engine_task',
+        phase: 'cancel_run_synchronously',
         priority: 'critical',
       },
-      { maxAttempts: 1 },
     );
-  };
-
-  const cancellationPendingError = (cause: unknown): Error => {
-    const error = new Error(
-      `Run cancellation was durably requested, but scheduler terminalization is pending for ${input.runId}.`,
-    );
-    Object.assign(error, {
-      code: RUNTIME_SCHEDULER_CANCELLATION_PENDING_CODE,
-      cause,
-    });
-    return error;
-  };
 
   const requestCancellation = async (reason?: string) => {
     await runCancellationSingleFlight(cancellationKey, async () => {
-      // First move the durable engine task into its cancellation lane. If the
-      // scheduler tables are briefly locked, the worker reconciler can finish
-      // the terminal write later without another user request piling up.
-      await cancelAbsurdTask();
-      try {
-        await delegate.cancel(reason);
-      } catch (error) {
-        throw cancellationPendingError(error);
-      }
-      try {
-        await cleanupPersistedRuntimeSandboxes();
-      } catch (error) {
-        // The scheduler terminal transaction already won. Its cleanup jobs are
-        // durable, so a best-effort eager cleanup failure must not turn a real
-        // cancellation into a false 502 or cause the caller to retry the
-        // terminal write.
-        console.warn('[absurd.runtime_sandbox_cleanup_deferred]', {
-          runId: input.runId,
-          error: error instanceof Error ? error.message : String(error),
-        });
-      }
+      // 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 cleanupPersistedRuntimeSandboxes = async () => {
-    const resources = await withRuntimeSchedulerClient(poolOptions, (client) =>
-      readPostgresSchedulerRuntimeResourcesForRun(
-        client,
-        { runId: input.runId },
-        effectiveOptions,
-      ),
-    );
-    const productionRefs = new Map<string, RuntimeSandboxRef>();
-    const workerOwnedRefs = new Map<string, RuntimeSandboxRef>();
-    for (const resource of resources) {
-      if (
-        !resource ||
-        typeof resource !== 'object' ||
-        Array.isArray(resource)
-      ) {
-        continue;
-      }
-      const record = resource as Record<string, unknown>;
-      const ref = runtimeSandboxRefFromResource(record);
-      if (!ref) continue;
-      const refKey = runtimeSandboxRefIdentityKey(ref);
-      // Modal credentials and all preview provider credentials are worker-only.
-      // This explicit task keeps deletion on the owning release lane. Legacy
-      // Daytona records predate runtimeEnvironment, so retain their marker.
-      const runtimeEnvironment =
-        record.runtimeEnvironment === 'preview' ||
-        record.daytonaEnvironment === 'preview'
-          ? 'preview'
-          : 'production';
-      if (runtimeEnvironment === 'preview' || ref.provider === 'modal') {
-        workerOwnedRefs.set(refKey, ref);
-        continue;
-      }
-      productionRefs.set(refKey, ref);
-    }
-    if (workerOwnedRefs.size > 0) {
-      const absurd = createAbsurdRuntimeClient(poolOptions, runsQueue);
-      await Promise.all(
-        [...workerOwnedRefs.values()].map((runtimeSandboxRef) => {
-          // sandboxId remains in the payload for workers deployed before the
-          // provider-scoped cleanup cutover. New workers use the versioned ref.
-          const params: AbsurdDaytonaSandboxCleanupTaskParams & {
-            runtimeSandboxRef: RuntimeSandboxRef;
-          } = {
-            runId: input.runId,
-            sandboxId: runtimeSandboxRef.resourceId,
-            runtimeSandboxRef,
-          };
-          return absurd.spawn(ABSURD_DAYTONA_SANDBOX_CLEANUP_TASK, params, {
-            queue: runsQueue,
-            idempotencyKey: `sandbox-cleanup:${input.runId}:${runtimeSandboxRefIdentityKey(runtimeSandboxRef)}`,
-            maxAttempts: ABSURD_PLAY_RUN_MAX_ATTEMPTS,
-            retryStrategy: ABSURD_PLAY_RUN_RETRY_STRATEGY,
-          });
-        }),
-      );
-    }
-    if (productionRefs.size === 0) return;
-    const cleanupResults = await Promise.allSettled(
-      [...productionRefs.values()].map(async (ref) => {
-        const outcome = await defaultRuntimeSandboxReconciliation.delete(ref);
-        if (!runtimeSandboxDeleteSucceeded(outcome)) {
-          throw new Error(
-            `${ref.provider} sandbox cleanup did not delete ${ref.resourceId}.`,
-          );
-        }
-      }),
-    );
-    for (const result of cleanupResults) {
-      if (result.status === 'rejected') {
-        console.warn('[absurd.runtime_sandbox_cleanup_failed]', {
-          runId: input.runId,
-          error:
-            result.reason instanceof Error
-              ? result.reason.message
-              : String(result.reason),
-        });
-      }
-    }
-  };
-
   return {
     ...delegate,
     runId: input.runId,

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

@@ -11852,15 +11852,26 @@ export async function cancelPostgresSchedulerRun(
       absurdTaskId: string;
       engineTaskTable: string | null;
     };
+    /**
+     * Optional control-plane ownership for the pending causal head. The
+     * caller resumes this same lease after commit to make cancellation visible
+     * synchronously in the canonical Run Ledger.
+     */
+    outboxLease?: { leaseOwner: string; leaseSeconds: number };
   },
   options?: Pick<PostgresSchedulerOptions, 'schema'>,
 ): Promise<boolean> {
   const reason = input.reason?.trim() || 'Cancelled.';
+  const outboxLeaseOwner = input.outboxLease?.leaseOwner.trim() || null;
+  const outboxLeaseSeconds = Math.max(
+    5,
+    Math.min(300, Math.floor(input.outboxLease?.leaseSeconds ?? 15)),
+  );
   const strandedFence = input.onlyIfStrandedPreExecution;
   const strandedEligibility = strandedFence
     ? `AND target.status = 'queued'
-       AND target.launch_json->>'absurdReleaseId' = $6
-       AND target.absurd_task_id = $7
+       AND target.launch_json->>'absurdReleaseId' = $8
+       AND target.absurd_task_id = $9
        AND NOT EXISTS (
          SELECT 1 FROM ${tableName('attempts', options)} AS attempt
          WHERE attempt.run_id = target.run_id
@@ -11991,16 +12002,46 @@ export async function cancelPostgresSchedulerRun(
           AND NULLIF(resource->>'sandboxId', '') IS NOT NULL
         ON CONFLICT (provider, sandbox_id, routing_domain_key) DO NOTHING
       ),
+      cancellation_outbox_head AS MATERIALIZED (
+        SELECT pending.event_id
+        FROM ${tableName('outbox', options)} AS pending
+        JOIN cancelled_run ON cancelled_run.run_id = pending.run_id
+        WHERE pending.delivered_at IS NULL
+          AND pending.failed_at IS NULL
+        ORDER BY ${runLedgerOrderSql('pending')}
+        LIMIT 1
+      ),
+      cancellation_outbox_lease AS (
+        UPDATE ${tableName('outbox', options)} AS pending
+        SET lease_owner = $6::text,
+            lease_expires_at = now() + make_interval(secs => $7::integer),
+            next_attempt_at = NULL
+        WHERE $6::text IS NOT NULL
+          AND pending.event_id IN (SELECT event_id FROM cancellation_outbox_head)
+        RETURNING pending.event_id
+      ),
       terminal_outbox AS (
         INSERT INTO ${tableName('outbox', options)} (
-          event_id, run_id, event_type, payload_json, created_at
+          event_id, run_id, event_type, payload_json, created_at,
+          next_attempt_at, lease_owner, lease_expires_at
         )
         SELECT
           'run-terminal:' || run_id,
           cancelled_run.run_id,
           'run.cancelled',
           jsonb_build_object('error', $5::text),
-          ${causalOutboxCreatedAt('cancelled_run.run_id', options)}
+          ${causalOutboxCreatedAt('cancelled_run.run_id', options)},
+          NULL,
+          CASE
+            WHEN EXISTS (SELECT 1 FROM cancellation_outbox_head) THEN NULL
+            ELSE $6::text
+          END,
+          CASE
+            WHEN $6::text IS NULL
+              OR EXISTS (SELECT 1 FROM cancellation_outbox_head)
+            THEN NULL
+            ELSE now() + make_interval(secs => $7::integer)
+          END
         FROM cancelled_run
         ON CONFLICT (event_id) DO NOTHING
       ),
@@ -12017,11 +12058,39 @@ export async function cancelPostgresSchedulerRun(
       postgresSchedulerNotifyChannel('terminal', options),
       JSON.stringify({ runId: input.runId, status: 'cancelled' }),
       reason,
+      outboxLeaseOwner,
+      outboxLeaseSeconds,
       ...(strandedFence
         ? [strandedFence.releaseId, strandedFence.absurdTaskId]
         : []),
     ],
   );
+  if (cancelled.rows.length === 0 && outboxLeaseOwner) {
+    // A competing terminal writer may win while this UPDATE waits on the run
+    // row. The next statement gets a fresh READ COMMITTED snapshot. Adopt its
+    // pending causal prefix before this enclosing cancellation transaction
+    // commits so the request can still project the winning terminal state
+    // without waiting for a background lease.
+    await client.query(
+      `UPDATE ${tableName('outbox', options)} AS pending
+          SET lease_owner = $2,
+              lease_expires_at = now() + make_interval(secs => $3::integer),
+              next_attempt_at = NULL
+        WHERE pending.event_id = (
+          SELECT candidate.event_id
+          FROM ${tableName('outbox', options)} AS candidate
+          JOIN ${tableName('runs', options)} AS terminal_run
+            ON terminal_run.run_id = candidate.run_id
+          WHERE candidate.run_id = $1
+            AND candidate.delivered_at IS NULL
+            AND candidate.failed_at IS NULL
+            AND terminal_run.status IN ('completed', 'failed', 'cancelled')
+          ORDER BY ${runLedgerOrderSql('candidate')}
+          LIMIT 1
+        )`,
+      [input.runId, outboxLeaseOwner, outboxLeaseSeconds],
+    );
+  }
   return cancelled.rows.length > 0;
 }
 
@@ -15369,7 +15438,12 @@ export async function readPendingPostgresSchedulerOutboxEvents(
           AND candidate.failed_at IS NULL
           AND coalesce(candidate.next_attempt_at, candidate.created_at) <= now()
           AND ($2::text IS NULL OR candidate.run_id = $2)
-          AND ($3::text IS NULL OR candidate.lease_expires_at IS NULL OR candidate.lease_expires_at <= now())
+          AND (
+            $3::text IS NULL
+            OR candidate.lease_owner = $3::text
+            OR candidate.lease_expires_at IS NULL
+            OR candidate.lease_expires_at <= now()
+          )
           -- A producer transaction may commit an older timestamp after a
           -- delivery has started. Ownership covers the run, not just the
           -- current oldest row: that late predecessor must wait as well.
@@ -15379,6 +15453,7 @@ export async function readPendingPostgresSchedulerOutboxEvents(
               AND active.delivered_at IS NULL
               AND active.lease_owner IS NOT NULL
               AND active.lease_expires_at > now()
+              AND active.lease_owner IS DISTINCT FROM $3::text
           )
           -- Competing projectors acquire one run through its oldest event.
           -- Locking this head prevents another projector from splitting the
@@ -15417,7 +15492,12 @@ export async function readPendingPostgresSchedulerOutboxEvents(
           -- its receipt stable independently of the recovery caller's limit.
           AND (outbox.event_type <> 'run.events' OR outbox.event_id = head.event_id)
           AND coalesce(outbox.next_attempt_at, outbox.created_at) <= now()
-          AND ($3::text IS NULL OR outbox.lease_expires_at IS NULL OR outbox.lease_expires_at <= now())
+          AND (
+            $3::text IS NULL
+            OR outbox.lease_owner = $3::text
+            OR outbox.lease_expires_at IS NULL
+            OR outbox.lease_expires_at <= now()
+          )
           -- A started terminal batch is deliberately stable across a retry.
           -- Do not enlarge it with a later event before acknowledgement: the
           -- runtime can replay the old idempotent append, but it cannot prove
@@ -15460,6 +15540,7 @@ export async function readPendingPostgresSchedulerOutboxEvents(
                   $3::text IS NOT NULL
                   AND predecessor.lease_expires_at IS NOT NULL
                   AND predecessor.lease_expires_at > now()
+                  AND predecessor.lease_owner IS DISTINCT FROM $3::text
                 )
               )
           )
@@ -16348,6 +16429,30 @@ export async function listPostgresSchedulerOutboxMaterializationPlans(
  */
 export type RunLedgerOutboxTokenAuthority = 'local_mint' | 'gateway';
 
+const POSTGRES_SCHEDULER_CANCELLATION_OUTBOX_LEASE_SECONDS = 15;
+
+/**
+ * Stable lease identity shared by the atomic scheduler cancellation and the
+ * app-side terminal projector. Cancellation can therefore fence a stale or
+ * slow background delivery inside the terminal transaction, then resume from
+ * that exact head immediately without waiting for its old lease to age.
+ */
+export function postgresSchedulerCancellationOutboxLease(runId: string): {
+  leaseOwner: string;
+  leaseSeconds: number;
+} {
+  const normalizedRunId = runId.trim();
+  if (!normalizedRunId) {
+    throw new Error('Cancellation outbox lease requires a run id.');
+  }
+  return {
+    leaseOwner: `run-ledger-cancel:${createHash('sha256')
+      .update(normalizedRunId)
+      .digest('hex')}`,
+    leaseSeconds: POSTGRES_SCHEDULER_CANCELLATION_OUTBOX_LEASE_SECONDS,
+  };
+}
+
 export type RunLedgerOutboxDispatchInput = {
   runtimeApi?: WorkerRuntimeApiContext | null;
   limit?: number;
@@ -16564,10 +16669,11 @@ export async function dispatchRunLedgerOutboxToLedgerBatchOnceWithClientScope(
                   AND active.delivered_at IS NULL
                   AND active.lease_owner IS NOT NULL
                   AND active.lease_expires_at > now()
+                  AND active.lease_owner IS DISTINCT FROM $2::text
               )
             FOR UPDATE OF runs SKIP LOCKED
           `,
-            [targetRunId],
+            [targetRunId, leaseOwner],
           )
         : await client.query<{ run_id: string }>(`
             WITH heads AS MATERIALIZED (

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.175",
+  version: "0.3.176",
   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/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.175",
+  version: "0.3.176",
   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.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.175",
+  version: "0.3.176",
   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.175",
+  version: "0.3.176",
   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.175";
+    readonly version: "0.3.176";
     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.175";
+    readonly version: "0.3.176";
     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.175",
+  version: "0.3.176",
   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.175",
+  version: "0.3.176",
   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.175",
+  "version": "0.3.176",
   "description": "GTM data CLI and TypeScript SDK for coding agents",
   "license": "MIT",
   "homepage": "https://code.deepline.com",