deepline 0.3.31 → 0.3.33

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

@@ -202,6 +202,7 @@ export async function checkSdkCompatibility(
         'X-Deepline-SDK-Version': SDK_VERSION,
         'X-Deepline-API-Major': String(SDK_API_MAJOR),
         'X-Deepline-API-Contract': SDK_API_CONTRACT,
+        'X-Deepline-CLI-Update-Preferences': '1',
       },
       signal: controller.signal,
     });

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

@@ -97,9 +97,11 @@ export type SdkSupportPolicy = {
    * Deliberately not a support floor. `commandMinimumSupported` says an older
    * client is BROKEN for a command and forces an update; this says only that
    * an older client never had the command at all. That difference matters in
-   * both directions: introducing a command must not auto-update anyone, and a
-   * support floor may not exceed the version being released, while an
-   * introduction version is a fact about an already-published release.
+   * both directions: introducing a command must not independently require an
+   * update, and a support floor may not exceed the version being released,
+   * while an introduction version is a fact about an already-published
+   * release. The general default-on freshness policy may still update an older
+   * installed CLI.
    *
    * It exists because agent skills are served by the backend and re-synced on
    * nearly every CLI invocation, while the CLI stays pinned. A release that
@@ -124,8 +126,8 @@ export type SdkSupportPolicy = {
   directToolsCompatibilityVersions?: readonly string[];
   /**
    * Diagnostic freshness threshold reported by `/api/v2/sdk/compat`.
-   * Stale-but-supported CLIs warn, but self-update is reserved for unsupported
-   * versions and rollback-directed updates.
+   * Ownership-aware installed CLIs auto-update when older; this value remains
+   * metadata for clients and operational diagnostics.
    */
   autoUpdatePatchLag?: number;
 };
@@ -142,6 +144,10 @@ export type SdkRelease = {
    * in its existing update message so older installed CLIs can print it too.
    */
   updateSummary?: string;
+  /** Capabilities stamped into the published package's `deepline` metadata. */
+  packageCapabilities: {
+    updatePreferences: 1;
+  };
   /** Named compatibility policies. This is the only authored contract policy. */
   contracts: DeeplineContractPolicy;
   /** Public support policy reported by `/api/v2/sdk/compat`. */
@@ -192,9 +198,13 @@ export const SDK_RELEASE = {
   // 0.3.0 introduces raw-v2: complete scrubbed provider responses are
   // available at toolResponse.rawV2 while toolResponse.raw and all declared
   // getters keep their established compatibility behavior.
-  version: '0.3.31',
+  // 0.3.1 deprecated the legacy `deepline enrich` command in favor of Plays.
+  version: '0.3.33',
   updateSummary:
-    'New raw-v2 tool responses preserve complete scrubbed provider envelopes at toolResponse.rawV2, including JSON:API included resources, links, cursors, and totals. Existing toolResponse.raw and declared getters keep working unchanged.',
+    'Automatic CLI updates are now enabled by default. To opt out, run `deepline settings autoupdate off`; use `deepline settings autoupdate on` to re-enable updates or `deepline settings autoupdate pin <version>` to hold an exact release. This release also adds raw-v2 tool responses at toolResponse.rawV2 while preserving existing toolResponse.raw and declared getters.',
+  packageCapabilities: {
+    updatePreferences: 1,
+  },
   contracts: {
     api: {
       name: 'sdk-http-api',
@@ -221,7 +231,7 @@ export const SDK_RELEASE = {
   },
   supportPolicy: {
     minimumSupported: '0.1.53',
-    deprecatedBelow: '0.1.219',
+    deprecatedBelow: '0.3.1',
     commandIntroducedIn: [
       {
         command: 'notifications',

package/dist/bundling-sources/shared_libs/play-runtime/app-runtime-api.ts

@@ -49,7 +49,10 @@ import {
   PLAY_RUNTIME_TEST_FAULT_HEADER,
   recognizedRuntimeTestFaultCount,
 } from '@shared_libs/play-runtime/test-runtime-seams';
-import { vercelProtectionBypassHeaders } from '@shared_libs/play-runtime/vercel-protection';
+import {
+  isVercelSecurityCheckpointResponse,
+  vercelProtectionBypassHeaders,
+} from '@shared_libs/play-runtime/vercel-protection';
 import type { RuntimeReceiptAction } from '@shared_libs/play-runtime/runtime-actions';
 import { RUNTIME_CAPACITY_POLICY } from '@shared_libs/play-runtime/runtime-capacity-policy';
 import { RUNTIME_RELIABILITY_POLICY } from '@shared_libs/play-runtime/runtime-reliability-policy';
@@ -478,10 +481,20 @@ function isRetryableAppRuntimeResponse(input: {
   action: RuntimeApiRequest['action'];
   status: number;
   body: string;
+  contentType: string | null;
 }): boolean {
   if (!isRetryableAppRuntimeAction(input.action)) {
     return false;
   }
+  // A WAF checkpoint is not a statement from the app about the idempotent
+  // projection. Do not make every 403 retryable: only this exact Vercel HTML
+  // response on a replay-safe action is an intermediary failure.
+  if (
+    input.action === 'append_run_events' &&
+    isVercelSecurityCheckpointResponse(input)
+  ) {
+    return true;
+  }
   // The app runtime may explicitly classify an otherwise-client-error status
   // as transient. Keep the structured delivery contract authoritative rather
   // than reducing every 4xx to permanent at the worker boundary.
@@ -1273,6 +1286,7 @@ async function postAppRuntimeApi<TResponse>(
         action: body.action,
         status: response.status,
         body: responseText,
+        contentType: response.headers.get('content-type'),
       })
     ) {
       const retryDelayMs = Math.max(
@@ -1299,6 +1313,7 @@ async function postAppRuntimeApi<TResponse>(
         action: body.action,
         status: response.status,
         body: responseText,
+        contentType: response.headers.get('content-type'),
       })
         ? 'retryable_http'
         : 'http_error',
@@ -1328,6 +1343,7 @@ async function postAppRuntimeApi<TResponse>(
         action: body.action,
         status: response.status,
         body: responseText,
+        contentType: response.headers.get('content-type'),
       }),
       detail: summarizeAppRuntimeErrorBody(responseText),
       boundaryLabel,

package/dist/bundling-sources/shared_libs/play-runtime/vercel-protection.ts

@@ -1,6 +1,7 @@
 type FetchLike = typeof fetch;
 
 const vercelProtectionCookieCache = new Map<string, Promise<string | null>>();
+const VERCEL_PROTECTION_COOKIE_PREFLIGHT_TIMEOUT_MS = 5_000;
 
 async function awaitWithSignal<T>(
   promise: Promise<T>,
@@ -45,6 +46,25 @@ export function vercelProtectionBypassHeader(
   return normalized ? { 'x-vercel-protection-bypass': normalized } : {};
 }
 
+/**
+ * A Vercel Firewall checkpoint is a transport/intermediary response, not an
+ * application authorization decision. Keep this deliberately narrow: callers
+ * still decide which replay-safe internal action may retry it.
+ */
+export function isVercelSecurityCheckpointResponse(input: {
+  status: number;
+  contentType: string | null | undefined;
+  body: string;
+}): boolean {
+  if (input.status !== 403) return false;
+  if (!/^text\/html(?:\s*;|$)/i.test(input.contentType?.trim() ?? '')) {
+    return false;
+  }
+  return /<title\b[^>]*>\s*Vercel Security Checkpoint\s*<\/title>/i.test(
+    input.body,
+  );
+}
+
 function setCookieHeaders(headers: Headers): string[] {
   const getter = (headers as Headers & { getSetCookie?: () => string[] })
     .getSetCookie;
@@ -75,14 +95,27 @@ export async function resolveVercelProtectionBypassCookie(input: {
 
   const cacheKey = `${baseUrl}\n${token}`;
   const cached = vercelProtectionCookieCache.get(cacheKey);
-  if (cached) return await awaitWithSignal(cached, input.signal);
+  if (cached) {
+    try {
+      return await awaitWithSignal(cached, input.signal);
+    } catch (error) {
+      if (input.signal?.aborted) throw input.signal.reason ?? error;
+      // A concurrent caller must retain the same header-only fallback as the
+      // caller that created the shared preflight promise.
+      return null;
+    }
+  }
 
   const promise = (async () => {
     const url = new URL(`${baseUrl}/api/v2/health`);
     addVercelProtectionBypassSearchParams(url, token);
+    // Keep the cache independent from an individual outbox lease. A caller
+    // may stop waiting, but the shared bootstrap is always bounded and either
+    // supplies a reusable cookie or evicts itself for a later retry.
     const response = await (input.fetchImpl ?? fetch)(url.toString(), {
       headers: { 'x-vercel-protection-bypass': token },
-    }).catch(() => null);
+      signal: AbortSignal.timeout(VERCEL_PROTECTION_COOKIE_PREFLIGHT_TIMEOUT_MS),
+    });
     return response ? cookieHeaderFromSetCookie(response.headers) : null;
   })();
   vercelProtectionCookieCache.set(cacheKey, promise);
@@ -91,7 +124,15 @@ export async function resolveVercelProtectionBypassCookie(input: {
       vercelProtectionCookieCache.delete(cacheKey);
     }
   });
-  return await awaitWithSignal(promise, input.signal);
+  try {
+    return await awaitWithSignal(promise, input.signal);
+  } catch (error) {
+    if (input.signal?.aborted) throw input.signal.reason ?? error;
+    // The header-only bypass remains useful when cookie bootstrap is briefly
+    // unavailable; do not turn a bounded preflight failure into a permanent
+    // delivery failure. The rejection handler above evicts this cache entry.
+    return null;
+  }
 }
 
 export async function vercelProtectionBypassHeaders(input: {