deepline 0.3.244 → 0.3.246

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

@@ -113,7 +113,10 @@ import type { MonitorFleetDefinition } from './monitor-fleets.js';
 import type { PlayStagedFileRef } from './plays/local-file-discovery.js';
 import type { PlayCompilerManifest } from '../../shared_libs/plays/compiler-manifest.js';
 import type { EnrichCompiledConfig } from './cli/enrich-play-compiler.js';
-import { RUNTIME_ENVIRONMENT_TOKEN_HEADER } from '../../shared_libs/play-runtime/coordinator-headers.js';
+import {
+  RUNTIME_ENVIRONMENT_TOKEN_HEADER,
+  RETAINED_PIPELINE_RECEIVERS_HEADER,
+} from '../../shared_libs/play-runtime/coordinator-headers.js';
 import {
   normalizePlayRuntimeEnvironment,
   normalizePlayRuntimeNamespace,
@@ -123,6 +126,7 @@ import {
 } from '../../shared_libs/play-runtime/runtime-environment.js';
 import {
   decodePlayRunPublicStatus,
+  isTerminalPlayRunLifecycleStatus,
   type PlayRunPublicStatus,
 } from '../../shared_libs/play-runtime/run-lifecycle-policy.js';
 export type SlackNotificationTarget =
@@ -209,7 +213,6 @@ function notificationObjectKey(kind: 'group' | 'destination') {
   return `${kind}.${globalThis.crypto.randomUUID()}`;
 }
 
-const TERMINAL_PLAY_STATUSES = new Set(['completed', 'failed', 'cancelled']);
 const MONITOR_NON_RETRYABLE_MUTATION_OPTIONS = {
   maxRetries: 0,
   exactUrlOnly: true,
@@ -403,7 +406,12 @@ function runtimeSelectionHeaders(
       'RUNTIME_ENVIRONMENT_TOKEN_REQUIRED',
     );
   }
-  return { [RUNTIME_ENVIRONMENT_TOKEN_HEADER]: token };
+  const receivers =
+    process.env.DEEPLINE_RUNTIME_RETAINED_PIPELINE_RECEIVERS?.trim();
+  return {
+    [RUNTIME_ENVIRONMENT_TOKEN_HEADER]: token,
+    ...(receivers ? { [RETAINED_PIPELINE_RECEIVERS_HEADER]: receivers } : {}),
+  };
 }
 
 function normalizeTestPolicyOverrides(
@@ -2306,7 +2314,9 @@ function normalizePlayRunStart(raw: Record<string, unknown>): PlayRunStart {
     ...(runPackage.run.dashboardUrl
       ? { dashboardUrl: runPackage.run.dashboardUrl }
       : {}),
-    ...(TERMINAL_PLAY_STATUSES.has(status) ? { finalStatus: runPackage } : {}),
+    ...(isTerminalPlayRunLifecycleStatus(status)
+      ? { finalStatus: runPackage }
+      : {}),
     package: runPackage,
   };
 }
@@ -2469,18 +2479,22 @@ function getPlayLiveEventPayload(
     : {};
 }
 
-function normalizeLiveStatus(value: unknown): PlayStatus['status'] | null {
+/** Run lifecycle events are the only events that can finish a watch. */
+function playLiveRunStatus(event: PlayLiveEvent): PlayStatus['status'] | null {
   if (
-    value === 'queued' ||
-    value === 'running' ||
-    value === 'waiting' ||
-    value === 'completed' ||
-    value === 'failed' ||
-    value === 'cancelled'
+    event.type !== 'play.run.snapshot' &&
+    event.type !== 'play.run.status' &&
+    event.type !== 'play.run.final_status'
   ) {
-    return value;
+    return null;
   }
-  return null;
+  const payload = getPlayLiveEventPayload(event);
+  return (
+    decodePlayRunPublicStatus(payload.status) ??
+    (isPlayRunPackage(payload)
+      ? decodePlayRunPublicStatus(payload.run.status)
+      : null)
+  );
 }
 
 function appendPlayLiveLogLines(
@@ -2545,12 +2559,7 @@ function updatePlayLiveStatusState(
       : isPlayRunPackage(payload)
         ? payload.run.id
         : state.runId;
-  const status =
-    normalizeLiveStatus(payload.status) ??
-    (isPlayRunPackage(payload)
-      ? normalizeLiveStatus(payload.run.status)
-      : null) ??
-    state.status;
+  const status = playLiveRunStatus(event) ?? state.status;
   const progressPayload = isRecord(payload.progress) ? payload.progress : {};
   // Snapshots no longer REPLACE accumulated logs (ADR-0009): the snapshot
   // only retains a bounded tail, so replacing would clobber the seq-keyed
@@ -4221,13 +4230,8 @@ export class DeeplineClient {
     runId: string,
     options?: RunsWatchOptions,
   ): Promise<PlayStatus> {
-    const state: PlayLiveStatusState = {
-      runId,
-      status: 'running',
-      logs: [],
-      lastLogSeq: 0,
-      latest: null,
-    };
+    // Forward events without retaining their log history. Only lifecycle
+    // evidence is needed here; the final package comes from the durable read.
     let terminalObserved = false;
     for await (const event of this.watchRunEvents(runId, {
       signal: options?.signal,
@@ -4235,19 +4239,20 @@ export class DeeplineClient {
       onRetry: options?.onRetry ?? options?.onReconnect,
     })) {
       options?.onEvent?.(event);
-      const status = updatePlayLiveStatusState(state, event);
-      if (status && TERMINAL_PLAY_STATUSES.has(status.status)) {
+      if (isTerminalPlayRunLifecycleStatus(playLiveRunStatus(event))) {
         terminalObserved = true;
       }
     }
     if (options?.signal?.aborted) {
       throw new DeeplineError('Run watch aborted.', undefined, 'ABORTED');
     }
-    if (terminalObserved) {
-      return await this.getRunStatus(runId);
-    }
     const refreshed = await this.getRunStatus(runId);
-    if (TERMINAL_PLAY_STATUSES.has(refreshed.status)) return refreshed;
+    if (
+      terminalObserved ||
+      isTerminalPlayRunLifecycleStatus(refreshed.status)
+    ) {
+      return refreshed;
+    }
     throw new DeeplineError(
       `Run watch for ${runId} ended before a terminal status.`,
       undefined,
@@ -4474,23 +4479,7 @@ export class DeeplineClient {
       `/api/v2/runs/${encodeURIComponent(runId)}${query}`,
       { headers: { 'x-deepline-run-status': '1' } },
     );
-    const responseRunStatus = isPlayRunPackage(response)
-      ? response.runStatus
-      : isPlayRunPackage(response.package)
-        ? response.package.runStatus
-        : response.runStatus;
-    const responseOverview = isPlayRunPackage(response)
-      ? response.overview
-      : isPlayRunPackage(response.package)
-        ? response.package.overview
-        : response.overview;
     const status = normalizePlayStatus(response);
-    if (isRecord(responseRunStatus)) {
-      status.runStatus = responseRunStatus as unknown as RunGetStatus;
-    }
-    if (isRecord(responseOverview)) {
-      status.overview = responseOverview as unknown as RunLifecycleStatus;
-    }
     if (options?.failedLogs !== true || status.status !== 'failed') {
       return status;
     }
@@ -5796,7 +5785,7 @@ export class DeeplineClient {
         options?.onProgress?.(status);
       }
 
-      if (TERMINAL_PLAY_STATUSES.has(status.status)) {
+      if (isTerminalPlayRunLifecycleStatus(status.status)) {
         terminalObserved = status;
       }
     }

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

@@ -38,6 +38,7 @@ import { readSdkSkillsLocalVersion } from './skills-version.js';
 import { deploymentProtectionHeaders } from './deployment-protection.js';
 import {
   ABSURD_RELEASE_OVERRIDE_HEADER,
+  RETAINED_PIPELINE_RECEIVERS_HEADER,
   COORDINATOR_INTERNAL_TOKEN_HEADER,
   COORDINATOR_URL_OVERRIDE_HEADER,
   PREFERRED_RECEIPT_GATEWAY_MACHINE_ID_HEADER,
@@ -345,6 +346,15 @@ export class HttpClient {
     if (runtimeTestFault?.trim()) {
       headers[PLAY_RUNTIME_TEST_FAULT_HEADER] = runtimeTestFault.trim();
     }
+    const retainedReceivers =
+      typeof process !== 'undefined'
+        ? process.env?.DEEPLINE_RUNTIME_RETAINED_PIPELINE_RECEIVERS?.trim()
+        : undefined;
+    if (retainedReceivers && coordinatorInternalToken?.trim()) {
+      headers[RETAINED_PIPELINE_RECEIVERS_HEADER] = retainedReceivers;
+      headers[COORDINATOR_INTERNAL_TOKEN_HEADER] =
+        coordinatorInternalToken.trim();
+    }
     if (absurdReleaseOverride?.trim() && coordinatorInternalToken?.trim()) {
       headers[ABSURD_RELEASE_OVERRIDE_HEADER] = absurdReleaseOverride.trim();
     }

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.244',
+  version: '0.3.246',
   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/runs/read-errors.ts

@@ -0,0 +1,19 @@
+import { DeeplineError } from '../errors.js';
+
+export function isTransientPlayRunReadError(error: unknown): boolean {
+  if (
+    error instanceof DeeplineError &&
+    error.code === 'PLAY_STREAM_NETWORK_ABORTED'
+  ) {
+    return true;
+  }
+  if (error instanceof DeeplineError && typeof error.statusCode === 'number') {
+    // 5xx responses and network-level failures may recover. Client errors,
+    // especially 404, stay visible instead of disappearing into a retry loop.
+    return error.statusCode >= 500 && error.statusCode < 600;
+  }
+  const text = error instanceof Error ? error.message : String(error);
+  return /auth validation backend timed out|coordinator \/submit(?:\?[^ ]*)? 5\d\d|Worker threw exception|Internal Server Error|Service Unavailable|fetch failed|eaddrnotavail|econnreset|etimedout|eai_again|socket hang up/i.test(
+    text,
+  );
+}

package/dist/bundling-sources/sdk/src/runs/watch-polling.ts

@@ -7,7 +7,7 @@ import {
   type PlayRunStreamDiffState,
   type PlayRunStreamEvent,
 } from '../../../shared_libs/play-runtime/run-snapshot-stream.js';
-import { isTransientPlayRunReadError } from '../stream-reconnect.js';
+import { isTransientPlayRunReadError } from './read-errors.js';
 
 /** The watch endpoint is a small authenticated REST read, polled every two seconds. */
 export const RUN_WATCH_POLL_INTERVAL_MS = 2_000;

package/dist/bundling-sources/shared_libs/play-runtime/coordinator-headers.ts

@@ -22,6 +22,16 @@ export const RUNTIME_SCHEDULER_SCHEMA_OVERRIDE_HEADER =
  */
 export const RUNTIME_ENVIRONMENT_TOKEN_HEADER =
   'x-deepline-runtime-environment-token';
+/** Authenticated target-owner assertion, issued only after deployment reproof. */
+export const RETAINED_PIPELINE_RECEIVERS_HEADER =
+  'x-deepline-retained-pipeline-receivers';
+export type RetainedPipelineReceivers = {
+  namespace: string;
+  schedulerSchema?: string;
+  backend: string;
+  callbackOrigin: string;
+  runtimeApiOrigin: string;
+};
 /**
  * Internal top-level `profile=absurd` launches, including deploy canaries, use
  * this header to pin an exact candidate release before activation. Public API

package/dist/bundling-sources/shared_libs/play-runtime/runner-app/runtime-terminal-push.ts

@@ -10,9 +10,7 @@ import {
   jsonByteLength,
   jsonByteLengthUpTo,
 } from '../output-size-limits';
-import {
-  PLAY_RUNTIME_TRANSPORT_ATTEMPT_HEADER,
-} from '../runtime-contract';
+import { PLAY_RUNTIME_TRANSPORT_ATTEMPT_HEADER } from '../runtime-contract';
 import {
   createRunnerGatewayTransportAttemptId,
   runnerGatewayTransportErrorCode,
@@ -595,8 +593,14 @@ export async function pushRunnerTerminal(
             : 'redirect',
         { status: response.status },
       );
-      // 4xx (scope/fence rejections) are deterministic — retrying cannot help.
-      if (response.status >= 400 && response.status < 500) {
+      // Gateway queue admission can shed this first-write-wins terminal with
+      // 429 before acquiring a database client. Retry the same terminal fact
+      // within the existing attempt budget; scope/fence rejections stay final.
+      if (
+        response.status >= 400 &&
+        response.status < 500 &&
+        response.status !== 429
+      ) {
         warn('terminal_push_rejected', {
           runId: options.runId,
           status: response.status,
@@ -606,9 +610,12 @@ export async function pushRunnerTerminal(
       }
     } catch (error) {
       lastError = error instanceof Error ? error.message : String(error);
-      reportTransport('network_error', {
-        errorCode: runnerGatewayTransportErrorCode(error),
-      });
+      reportTransport(
+        requestController.signal.aborted ? 'timeout' : 'network_error',
+        {
+          errorCode: runnerGatewayTransportErrorCode(error),
+        },
+      );
     } finally {
       clearTimeout(requestTimeout);
     }

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

@@ -488,10 +488,15 @@ async function main() {
     checkpointBytes: 0,
     tableNamespace: null,
   });
+  const requestBody = JSON.stringify({
+    action: 'runner_terminal',
+    runId: push.runId,
+    result,
+  });
   for (let attempt = 1; attempt <= 3; attempt += 1) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 10000);
     try {
-      const controller = new AbortController();
-      const timer = setTimeout(() => controller.abort(), 10000);
       const response = await fetch(gateway + '/api/v2/plays/runtime', {
         method: 'POST',
         headers: {
@@ -501,28 +506,32 @@ async function main() {
             ? { 'fly-force-instance-id': preferredGatewayMachineId }
             : {}),
         },
-        body: JSON.stringify({
-          action: 'runner_terminal',
-          runId: push.runId,
-          result,
-        }),
+        body: requestBody,
         signal: controller.signal,
         redirect: 'manual',
       });
-      clearTimeout(timer);
+      // Keep the HTTP deadline through body consumption so retries do not
+      // leave an unread socket behind. The status already acknowledges the
+      // durable terminal even if its diagnostic response body is interrupted.
+      await response.text().catch(() => '');
       if (response.ok) {
         writeDiagnostic('[crash-terminal] pushed status=' + result.status);
         return;
       }
       writeDiagnostic('[crash-terminal] rejected http=' + response.status);
-      // Deterministic scope/fence rejections cannot succeed on retry.
-      if (response.status >= 400 && response.status < 500) return;
+      // A 429 is gateway admission pressure, not a scope/fence rejection.
+      // Replaying this terminal fact never replays customer execution.
+      if (response.status >= 400 && response.status < 500 && response.status !== 429) return;
     } catch (error) {
       writeDiagnostic(
         '[crash-terminal] transport ' + (error && error.message ? error.message : String(error)),
       );
+    } finally {
+      clearTimeout(timer);
+    }
+    if (attempt < 3) {
+      await new Promise((resolveDelay) => setTimeout(resolveDelay, attempt * 1000));
     }
-    await new Promise((resolveDelay) => setTimeout(resolveDelay, attempt * 1000));
   }
   writeDiagnostic('[crash-terminal] exhausted retries');
 }

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

@@ -937,6 +937,7 @@ export async function withRuntimeSchedulerClient<T>(
     throw error;
   }
   const admissionWaitMs = performance.now() - admissionStartedAt;
+  let unsampledAdmissionWaitMs = admissionWaitMs;
   let lastError: unknown = null;
   try {
     throwIfSchedulerAborted(signal);
@@ -996,7 +997,14 @@ export async function withRuntimeSchedulerClient<T>(
           entry.stats.peakTotalClients,
           entry.pool.totalCount,
         );
-        pushSample(entry.stats.acquireWait, acquireWaitMs);
+        // The admission gate owns the local queue before pg.Pool sees this
+        // checkout. Include that wait once, on the operation's first acquired
+        // client; retries retain the permit and only add their own connect wait.
+        pushSample(
+          entry.stats.acquireWait,
+          unsampledAdmissionWaitMs + acquireWaitMs,
+        );
+        unsampledAdmissionWaitMs = 0;
 
         // A checked-out pg client emits 'error' (not via the pool) when its TCP
         // connection dies while idle — e.g. a worker holding a client across a
@@ -1255,6 +1263,7 @@ export type RuntimeSchedulerPoolStats = {
   idleCount: number;
   waitingCount: number;
   acquires: number;
+  /** Successful checkout latency, including local admission once per operation. */
   acquireWaitP50Ms: number | null;
   acquireWaitP95Ms: number | null;
   saturationRejections: number;
@@ -1388,6 +1397,8 @@ export async function probeRuntimeSchedulerDirectSession(input: {
     connectionString: deriveDirectDatabaseUrl(input.url),
     application_name:
       input.applicationName ?? 'deepline-runtime-direct-session-preflight',
+    connectionTimeoutMillis: RUNTIME_SCHEDULER_POOL_DEFAULTS.connectTimeoutMs,
+    query_timeout: RUNTIME_SCHEDULER_POOL_DEFAULTS.queryTimeoutMs,
   });
   try {
     await client.connect();
@@ -1648,6 +1659,8 @@ export function createPgNotifyHub(input: {
     const next = (input.createClient ?? ((config) => new Client(config)))({
       connectionString: directUrl,
       application_name: input.applicationName ?? 'deepline-runtime-notify-hub',
+      connectionTimeoutMillis: RUNTIME_SCHEDULER_POOL_DEFAULTS.connectTimeoutMs,
+      query_timeout: RUNTIME_SCHEDULER_POOL_DEFAULTS.queryTimeoutMs,
     });
     try {
       await next.connect();

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

@@ -8453,6 +8453,80 @@ export async function readPostgresSchedulerLaunchForAttemptLease(
   return row ? parseLaunchJson(row.launch_json) : null;
 }
 
+/** Identity, signing authority, and origins needed to issue an attempt token. */
+const POSTGRES_SCHEDULER_ATTEMPT_AUTHORITY_FIELDS = [
+  'runId',
+  'orgId',
+  'playName',
+  'userId',
+  'userEmail',
+  'baseUrl',
+  'runtimeApiBaseUrl',
+  'runtimeTokenOrigin',
+  'runtimeBackend',
+  'runtimeAuthority',
+] as const;
+
+export type PostgresSchedulerAttemptAuthority = Pick<
+  PlaySchedulerSubmitInput,
+  (typeof POSTGRES_SCHEDULER_ATTEMPT_AUTHORITY_FIELDS)[number]
+>;
+
+/**
+ * Prove the same attempt lease as the full execution reader, returning only
+ * the token issuer's authority. Input, graph, and artifact bytes never cross
+ * this SQL seam or occupy a Vercel checkout during JSON decoding. The authority
+ * descriptor is retained intact for the existing validator and deploy skew;
+ * its admitted secrets and fixture configuration are not execution payloads.
+ */
+export async function readPostgresSchedulerAttemptAuthorityForLease(
+  client: PostgresSchedulerQueryClient,
+  input: { runId: string; attempt: number; leaseToken: string },
+  options?: Pick<PostgresSchedulerOptions, 'schema'>,
+): Promise<PostgresSchedulerAttemptAuthority | null> {
+  const fields = POSTGRES_SCHEDULER_ATTEMPT_AUTHORITY_FIELDS;
+  // Keep JSON types intact. A text record column would coerce malformed launch
+  // scalars into strings, bypassing the full reader's required-field checks.
+  const columns = [...fields, 'playId', 'executorToken']
+    .map((field) => `${quoteIdent(field)} jsonb`)
+    .join(', ');
+  const result = await client.query<
+    PostgresSchedulerAttemptAuthority & {
+      launch_required_fields_valid: boolean;
+    }
+  >(
+    `
+      SELECT ${fields.map((field) => `launch.${quoteIdent(field)}`).join(', ')},
+             ${['runId', 'playId', 'playName', 'executorToken', 'baseUrl']
+               .map(
+                 (field) =>
+                   `jsonb_typeof(launch.${quoteIdent(field)}) = 'string'`,
+               )
+               .join(' AND ')} AS launch_required_fields_valid
+      FROM ${tableName('runs', options)} AS runs
+      JOIN ${tableName('attempts', options)} AS attempts
+        ON attempts.run_id = runs.run_id
+      CROSS JOIN LATERAL jsonb_to_record(runs.launch_json) AS launch(${columns})
+      WHERE runs.run_id = $1
+        AND runs.status IN ('queued', 'running', 'waiting')
+        AND attempts.attempt = $2
+        AND attempts.lease_token = $3
+        AND attempts.status IN ('claimed', 'running', 'waiting')
+      LIMIT 1
+    `,
+    [input.runId, input.attempt, input.leaseToken],
+  );
+  const row = result.rows[0];
+  if (!row) return null;
+  const { launch_required_fields_valid, ...authority } = row;
+  if (launch_required_fields_valid !== true) {
+    throw new Error(
+      'Postgres scheduler launch_json is missing required fields.',
+    );
+  }
+  return authority;
+}
+
 /**
  * Absurd scheduler backend: persist the vendored engine's task id on the run
  * row after `spawn`. Idempotent (last write wins); a re-submit under the same

package/dist/bundling-sources/shared_libs/plays/execution-pipeline.ts

@@ -4,9 +4,11 @@ import { staticPipelineStorageCodec } from './static-pipeline-storage-codec';
 
 export {
   retainedPlayPipelineFields,
+  WRITE_RETAINED_PIPELINE_GRAPHS,
   type RetainedPlayContract,
   type RetainedPipelineCarrier,
   encodeRetainedPlayPipelines,
+  createRetainedPlayPipelinesForTransport,
   hydrateRetainedPlayPipelines,
   prepareRetainedPlayPipelinesForTransport,
   type RetainedPipelineGraph,

package/dist/bundling-sources/shared_libs/plays/retained-pipeline-graph.ts

@@ -6,7 +6,7 @@
  * This is an additive named representation. Readers must be deployed before
  * WRITE_RETAINED_PIPELINE_GRAPHS is enabled in a separate release.
  */
-export const WRITE_RETAINED_PIPELINE_GRAPHS = false;
+export const WRITE_RETAINED_PIPELINE_GRAPHS = true;
 
 type Scalar = null | boolean | number | string;
 type GraphValue = Scalar | { ref: number };
@@ -255,12 +255,18 @@ function hydrateContractRoots(
   return result;
 }
 
-/** Production writers remain inert until the separate reader rollout completes. */
+/** Create a graph only when the owner has selected reader-capable receivers. */
+export function createRetainedPlayPipelinesForTransport<T>(input: T): T {
+  return WRITE_RETAINED_PIPELINE_GRAPHS
+    ? encodeRetainedPlayPipelines(input)
+    : prepareRetainedPlayPipelinesForTransport(input);
+}
+
+/** Forward an immutable launch in its original representation. */
 export function prepareRetainedPlayPipelinesForTransport<T>(input: T): T {
-  // Reader-only builds must preserve new representations when forwarding
-  // them. The rollout switch controls creation from legacy envelopes only.
-  return WRITE_RETAINED_PIPELINE_GRAPHS ||
-    (record(input) && input.retainedPipelineGraph !== undefined)
+  // A historical launch may still call an older pinned app after adoption.
+  // New workers and projectors must not upgrade that receiver's wire format.
+  return record(input) && input.retainedPipelineGraph !== undefined
     ? encodeRetainedPlayPipelines(input)
     : input;
 }

package/dist/bundling-sources/shared_libs/plays/static-pipeline-storage-codec.ts

@@ -10,7 +10,6 @@ import {
   retainedPlayPipelineFields,
   encodeRetainedPlayPipelines,
   hydrateRetainedPlayPipelines,
-  WRITE_RETAINED_PIPELINE_GRAPHS,
   type RetainedPipelineGraph,
   type RetainedPipelineCarrier,
 } from './retained-pipeline-graph';
@@ -29,7 +28,7 @@ function readExecutionPipeline(
   return readStoredStaticPipeline(record);
 }
 
-/** Runs use the shared graph after all storage readers have been deployed. */
+/** Preserve the representation selected by the immutable launch owner. */
 function executionStorageFields(
   pipeline: PlayStaticPipeline | null | undefined,
   carrier?: RetainedPipelineCarrier,
@@ -38,11 +37,7 @@ function executionStorageFields(
   staticPipelineV2?: ReturnType<typeof createStoredStaticPipelineV2>;
   retainedPipelineGraph?: RetainedPipelineGraph;
 } {
-  if (
-    (!WRITE_RETAINED_PIPELINE_GRAPHS &&
-      carrier?.retainedPipelineGraph === undefined) ||
-    pipeline === undefined
-  ) {
+  if (carrier?.retainedPipelineGraph === undefined || pipeline === undefined) {
     return createStaticPipelineStorageFields(pipeline);
   }
   const compact = encodeRetainedPlayPipelines(