deepline 0.3.32 → 0.3.34

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.32',
+  // 0.3.1 deprecated the legacy `deepline enrich` command in favor of Plays.
+  version: '0.3.34',
   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/execution-protocol.ts

@@ -0,0 +1,71 @@
+/**
+ * Execution ABI for a persisted Play launch.
+ *
+ * This is deliberately separate from a customer Play artifact version and a
+ * worker image/release id. The artifact is immutable customer code; this
+ * protocol names the stable coordinator <-> worker <-> runner contract used
+ * to resume that artifact. A worker may support several protocol versions,
+ * but it must reject an unknown one loudly rather than guessing how to replay
+ * a persisted run.
+ */
+export const PLAY_RUNTIME_PROTOCOL = {
+  /** Launches written before this field existed. */
+  legacy: 0,
+  /** Current scheduler/runner protocol. */
+  current: 1,
+} as const;
+
+export type PlayRuntimeProtocolVersion =
+  (typeof PLAY_RUNTIME_PROTOCOL)[keyof typeof PLAY_RUNTIME_PROTOCOL];
+
+const SUPPORTED_PROTOCOLS = new Set<number>([
+  PLAY_RUNTIME_PROTOCOL.legacy,
+  PLAY_RUNTIME_PROTOCOL.current,
+]);
+
+/** New launches always get an explicit protocol snapshot. */
+export function protocolForNewPlayRuntimeLaunch(
+  value?: PlayRuntimeProtocolVersion | null,
+): PlayRuntimeProtocolVersion {
+  return value == null
+    ? PLAY_RUNTIME_PROTOCOL.current
+    : protocolForPersistedPlayRuntimeLaunch(value);
+}
+
+/** Missing is valid only for historic rows written before the field existed. */
+export function protocolForPersistedPlayRuntimeLaunch(
+  value: unknown,
+): PlayRuntimeProtocolVersion {
+  if (value == null) return PLAY_RUNTIME_PROTOCOL.legacy;
+  if (
+    typeof value === 'number' &&
+    Number.isSafeInteger(value) &&
+    SUPPORTED_PROTOCOLS.has(value)
+  ) {
+    return value as PlayRuntimeProtocolVersion;
+  }
+  throw new Error(
+    `Unsupported Play runtime protocol ${JSON.stringify(value)}. The run remains durable but requires a worker with an explicit compatibility handler.`,
+  );
+}
+
+/**
+ * A worker declares the persisted protocols it can execute. Keep an old
+ * protocol here until every open run using it is terminal and retained history
+ * no longer needs replay support; do not use deployment SHA as this boundary.
+ */
+export const WORKER_SUPPORTED_PLAY_RUNTIME_PROTOCOLS = [
+  PLAY_RUNTIME_PROTOCOL.legacy,
+  PLAY_RUNTIME_PROTOCOL.current,
+] as const satisfies readonly PlayRuntimeProtocolVersion[];
+
+export function assertWorkerSupportsPlayRuntimeProtocol(
+  value: unknown,
+  supported: readonly PlayRuntimeProtocolVersion[] = WORKER_SUPPORTED_PLAY_RUNTIME_PROTOCOLS,
+): PlayRuntimeProtocolVersion {
+  const protocol = protocolForPersistedPlayRuntimeLaunch(value);
+  if (supported.includes(protocol)) return protocol;
+  throw new Error(
+    `Play runtime protocol ${protocol} is not supported by this worker. Refuse to execute rather than replaying with an incompatible runtime.`,
+  );
+}

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

@@ -22,6 +22,7 @@ import type { PlayRunnerRuntimeTiming } from './protocol';
 import type { RuntimeTestPolicyOverrides } from './test-runtime-seams';
 import type { PlayRunInputPayload } from './play-input';
 import type { RuntimeSandboxPlacementPolicyId } from './runtime-sandbox-placement-policy';
+import type { PlayRuntimeProtocolVersion } from './execution-protocol';
 
 export const PLAY_SCHEDULER_BACKENDS = {
   /**
@@ -48,6 +49,8 @@ export type PlaySchedulerSubmitInput = {
   runtimeArtifact?: unknown;
   artifactHash: string;
   graphHash: string;
+  /** Immutable scheduler/worker/runner ABI snapshot (not a Git SHA). */
+  runtimeProtocolVersion?: PlayRuntimeProtocolVersion | null;
   input: PlayRunInputPayload;
   /** Convex metadata for the exact input saved before scheduler submission. */
   inputFileId?: string;