deepline 0.1.214 → 0.1.216

package/dist/bundling-sources/shared_libs/play-runtime/providers.ts

@@ -27,6 +27,22 @@ export type PlayRuntimeProviderDescriptor = {
   label: string;
 };
 
+export const PLAY_RUNTIME_PROVIDER_DISABLED_CODE =
+  'PLAY_RUNTIME_PROVIDER_DISABLED' as const;
+
+export class PlayRuntimeProviderDisabledError extends Error {
+  readonly code = PLAY_RUNTIME_PROVIDER_DISABLED_CODE;
+  readonly profile: PlayRuntimeProviderId;
+
+  constructor(profile: PlayRuntimeProviderId) {
+    super(
+      `Play runtime profile "${profile}" is disabled. Deepline runs now execute on the "absurd" profile.`,
+    );
+    this.name = 'PlayRuntimeProviderDisabledError';
+    this.profile = profile;
+  }
+}
+
 export const PLAY_RUNTIME_PROVIDERS: Record<
   PlayRuntimeProviderId,
   PlayRuntimeProviderDescriptor
@@ -57,6 +73,14 @@ export function defaultPlayRuntimeProvider(): PlayRuntimeProviderDescriptor {
   return PLAY_RUNTIME_PROVIDERS.absurd;
 }
 
+export function assertPlayRuntimeProviderEnabled(
+  provider: PlayRuntimeProviderDescriptor,
+): void {
+  if (provider.id === PLAY_RUNTIME_PROVIDER_IDS.workersEdge) {
+    throw new PlayRuntimeProviderDisabledError(provider.id);
+  }
+}
+
 export function resolvePlayRuntimeProvider(
   override?: string | null,
 ): PlayRuntimeProviderDescriptor {
@@ -73,3 +97,11 @@ export function resolvePlayRuntimeProvider(
   }
   return defaultPlayRuntimeProvider();
 }
+
+export function resolveEnabledPlayRuntimeProvider(
+  override?: string | null,
+): PlayRuntimeProviderDescriptor {
+  const provider = resolvePlayRuntimeProvider(override);
+  assertPlayRuntimeProviderEnabled(provider);
+  return provider;
+}

package/dist/bundling-sources/shared_libs/play-runtime/run-failure.ts

@@ -2,6 +2,8 @@ const CLOUDFLARE_DURABLE_OBJECT_RESET_RE =
   /Durable Object.*(?:code (?:was|has been) updated|storage caused object)/;
 const CLOUDFLARE_WORKER_SUBREQUEST_LIMIT_RE =
   /Too many subrequests by single Worker invocation/i;
+const CLOUDFLARE_WORKFLOW_ENDPOINT_UNAVAILABLE_RE =
+  /The requested endpoint could not be found, or you don't have access to it\. Please check the provided ID and try again\./i;
 const VERCEL_RUNTIME_API_DEPLOYMENT_MISSING_RE =
   /runtime API 404:[\s\S]*(?:DeploymentNotFound|DEPLOYMENT_NOT_FOUND|requested deployment .*exist|deployment could not be found on Vercel)/i;
 
@@ -9,6 +11,8 @@ export const PLATFORM_DEPLOY_INTERRUPTED_MESSAGE =
   'Run interrupted by a platform deploy. Deepline retries this automatically when possible; if this error is still visible, re-run the same command.';
 export const PLATFORM_WORKER_SUBREQUEST_INTERRUPTED_MESSAGE =
   'Worker subrequest limit hit. Deepline retries automatically; if still visible, re-run.';
+export const PLATFORM_WORKFLOW_ENDPOINT_INTERRUPTED_MESSAGE =
+  'Cloudflare workflow control was temporarily unavailable. Deepline retries automatically; if still visible, re-run.';
 
 export const INTERNAL_RUNTIME_STORAGE_ERROR_MESSAGE =
   'Internal play runtime storage failed. Please retry the run; if this keeps happening, contact Deepline support with the run ID.';
@@ -171,6 +175,15 @@ export function normalizePlayRunFailure(error: unknown): PlayRunFailureDetails {
       cause,
     };
   }
+  if (CLOUDFLARE_WORKFLOW_ENDPOINT_UNAVAILABLE_RE.test(cause)) {
+    return {
+      code: 'PLATFORM_WORKFLOW_ENDPOINT_INTERRUPTED',
+      phase: 'runtime',
+      message: PLATFORM_WORKFLOW_ENDPOINT_INTERRUPTED_MESSAGE,
+      retryable: true,
+      cause,
+    };
+  }
   const playDepthBudgetMatch = cause.match(
     /Play execution playDepth budget exceeded \((\d+)\/(\d+)\)\./,
   );

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

@@ -27,6 +27,7 @@ type DaytonaPayloadEnvelope = {
 export type StagedDaytonaPayload = {
   workDir: string;
   command: string;
+  readyPath: string;
   outputPath: string;
   exitCodePath: string;
   progressEventPath: string;
@@ -343,6 +344,7 @@ export async function stageDaytonaRunnerPayload(input: {
 
   const outputPath = `${workDir}/deepline-play-output-${randomUUID()}.log`;
   const exitCodePath = `${workDir}/deepline-play-exit-${randomUUID()}.txt`;
+  const readyPath = `${workDir}/deepline-play-ready-${randomUUID()}.json`;
   const progressEventPath = `${workDir}/deepline-play-progress-${randomUUID()}.jsonl`;
   const runnerTraceEnv =
     process.env.DEEPLINE_RUNTIME_RECEIPT_TRACE === '1'
@@ -354,17 +356,18 @@ export async function stageDaytonaRunnerPayload(input: {
     configPath,
     artifactCodePath,
     crashPusherPath,
-  })} && DEEPLINE_PLAY_RUNNER_PROGRESS_EVENT_PATH=${shellQuote(progressEventPath)} DEEPLINE_PLAY_RUNNER_STDOUT_EVENT_MODE=compact ${runnerTraceEnv}node ${shellQuote(runnerPath)} ${shellQuote(configPath)}`;
+  })} && DEEPLINE_PLAY_RUNNER_READY_PATH=${shellQuote(readyPath)} DEEPLINE_PLAY_RUNNER_PROGRESS_EVENT_PATH=${shellQuote(progressEventPath)} DEEPLINE_PLAY_RUNNER_STDOUT_EVENT_MODE=compact ${runnerTraceEnv}node ${shellQuote(runnerPath)} ${shellQuote(configPath)}`;
   // Crash-containment epilogue: runs UNCONDITIONALLY after the runner exits and
   // pushes the parsed (or synthesized) terminal to the gateway so the parked
   // worker wakes within seconds of ANY runner death — process.exit abuse, OOM
   // SIGKILL, or a crash before the in-process push. Idempotent against a
   // successful in-runner push (terminals are first-write-wins).
-  const command = `rm -f ${shellQuote(outputPath)} ${shellQuote(exitCodePath)} ${shellQuote(progressEventPath)} ${shellQuote(`${progressEventPath}.*`)}; ( ${runnerCommand} ) > ${shellQuote(outputPath)} 2>&1; code=$?; printf '%s' "$code" > ${shellQuote(exitCodePath)}; node ${shellQuote(crashPusherPath)} ${shellQuote(configPath)} "$code" ${shellQuote(outputPath)} >> ${shellQuote(outputPath)} 2>&1 || true; printf 'deepline runner output captured: %s\\n' ${shellQuote(outputPath)}; exit "$code"`;
+  const command = `rm -f ${shellQuote(outputPath)} ${shellQuote(exitCodePath)} ${shellQuote(readyPath)} ${shellQuote(progressEventPath)} ${shellQuote(`${progressEventPath}.*`)}; ( ${runnerCommand} ) > ${shellQuote(outputPath)} 2>&1; code=$?; printf '%s' "$code" > ${shellQuote(exitCodePath)}; node ${shellQuote(crashPusherPath)} ${shellQuote(configPath)} "$code" ${shellQuote(outputPath)} >> ${shellQuote(outputPath)} 2>&1 || true; printf 'deepline runner output captured: %s\\n' ${shellQuote(outputPath)}; exit "$code"`;
 
   return {
     workDir: input.workDir,
     command,
+    readyPath,
     outputPath,
     exitCodePath,
     progressEventPath,

package/dist/bundling-sources/shared_libs/play-runtime/runner-backends/backends/daytona-session-execution.ts

@@ -112,6 +112,16 @@ export type DetachedDaytonaCommandStart = {
   cmdId: string;
 };
 
+const DAYTONA_RUNNER_READY_TIMEOUT_MS = 3_000;
+const DAYTONA_RUNNER_READY_POLL_MS = 250;
+
+export class DaytonaRunnerInitializationError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'DaytonaRunnerInitializationError';
+  }
+}
+
 /**
  * Start `command` detached in a fresh session. Returns the session + command id
  * immediately (no await on completion).
@@ -137,3 +147,59 @@ export async function startDetachedDaytonaCommand(input: {
   }
   return { sessionId: input.sessionId, cmdId };
 }
+
+/**
+ * A detached command id only proves that Daytona accepted the request. Before
+ * the worker parks, require a marker written by the initialized runner process.
+ * This closes the unobservable handoff where a sandbox or command disappears
+ * after executeSessionCommand but before the first gateway heartbeat.
+ */
+export async function confirmDetachedDaytonaRunnerReady(input: {
+  sandbox: DaytonaSandbox;
+  sessionId: string;
+  cmdId: string;
+  readyPath: string;
+  exitCodePath: string;
+  timeoutMs?: number;
+  pollMs?: number;
+  now?: () => number;
+  sleep?: (ms: number) => Promise<void>;
+}): Promise<void> {
+  const now = input.now ?? Date.now;
+  const sleep =
+    input.sleep ??
+    ((ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms)));
+  const timeoutMs = Math.max(
+    1,
+    input.timeoutMs ?? DAYTONA_RUNNER_READY_TIMEOUT_MS,
+  );
+  const pollMs = Math.max(1, input.pollMs ?? DAYTONA_RUNNER_READY_POLL_MS);
+  const deadline = now() + timeoutMs;
+  let markerDiagnosis = 'ready_marker_unavailable';
+
+  while (now() < deadline) {
+    try {
+      const marker = await input.sandbox.fs.downloadFile(input.readyPath, 2);
+      const parsed = JSON.parse(marker.toString('utf-8')) as {
+        ready?: unknown;
+      };
+      if (parsed.ready === true) return;
+      markerDiagnosis = 'ready_marker_invalid';
+    } catch {
+      markerDiagnosis = 'ready_marker_unavailable';
+    }
+    await sleep(Math.min(pollMs, Math.max(1, deadline - now())));
+  }
+
+  const diagnostic = await inspectDetachedDaytonaStartup({
+    sandbox: input.sandbox,
+    sessionId: input.sessionId,
+    cmdId: input.cmdId,
+    exitCodePath: input.exitCodePath,
+  });
+  const oomIndicated =
+    diagnostic.exitCode === 137 || diagnostic.exitCodeFile === 137;
+  throw new DaytonaRunnerInitializationError(
+    `RUNTIME_SANDBOX_START_FAILED: Daytona accepted detached command ${input.cmdId} in sandbox ${input.sandbox.id}, but the play runner did not initialize within ${timeoutMs}ms. Marker diagnosis: ${markerDiagnosis}. Daytona diagnosis: ${JSON.stringify(diagnostic)}. OOM is ${oomIndicated ? 'indicated by exit code 137' : 'not confirmed by the available Daytona evidence'}. The play was stopped and was not retried.`,
+  );
+}

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

@@ -33,7 +33,8 @@ import {
 } from './daytona-lifecycle';
 import { stageDaytonaRunnerPayload } from './daytona-payload-transport';
 import {
-  inspectDetachedDaytonaStartup,
+  confirmDetachedDaytonaRunnerReady,
+  DaytonaRunnerInitializationError,
   startDetachedDaytonaCommand,
 } from './daytona-session-execution';
 
@@ -45,8 +46,6 @@ const DAYTONA_RUNTIME_INITIALIZATION_MAX_ATTEMPTS = 2;
 const DAYTONA_INFRASTRUCTURE_MAX_ATTEMPTS = 2;
 const DAYTONA_UPLOAD_MAX_ATTEMPTS = 2;
 const DAYTONA_UPLOAD_ATTEMPT_DEADLINE_MS = 90_000;
-const DAYTONA_STARTUP_DIAGNOSTIC_DELAY_MS = 15_000;
-const DAYTONA_STARTUP_TRACE_ENV = 'DEEPLINE_DAYTONA_STARTUP_TRACE';
 
 const RUNTIME_POSTGRES_CONNECT_RETRY_PATTERN =
   /\bRuntime Postgres\b.*\b(connection timed out|connect timeout|ETIMEDOUT|ECONNRESET|ECONNREFUSED|Connection terminated|Connection ended unexpectedly)\b/i;
@@ -397,6 +396,7 @@ export function retryableRuntimeInitializationFailureReason(
 }
 
 function isRetryableDaytonaInfrastructureFailure(error: unknown): boolean {
+  if (error instanceof DaytonaRunnerInitializationError) return false;
   const message = error instanceof Error ? error.message : String(error);
   if (!message || /cancelled|aborted/i.test(message)) {
     return false;
@@ -715,12 +715,11 @@ export const daytonaPlayRunnerBackend: PlayRunnerBackend = {
           });
           // Push execution (B2-final, park-and-wake): start the runner command
           // DETACHED via a Daytona session and return a `detached_runner`
-          // suspension immediately — the worker parks on it (releasing its
-          // claim, freeing the slot) and wakes on the runner's pushed terminal
-          // or the ceiling timeout. Nothing here awaits completion: no held
-          // socket, no poll loop, no per-second sandbox file reads. The sandbox
-          // MUST outlive this return (the runner is executing inside it); the
-          // wake leg owns finalize + sandbox GC.
+          // suspension after the runner writes its one-time ready marker. The
+          // marker is the handoff proof: a Daytona cmdId alone does not prove
+          // the sandbox process initialized. After that bounded startup check,
+          // the worker parks (releasing its claim and slot) and wakes only on
+          // the runner's pushed terminal or the ceiling timeout.
           const sessionId = `deepline-play-${randomUUID()}`;
           let start: Awaited<ReturnType<typeof startDetachedDaytonaCommand>>;
           try {
@@ -744,6 +743,16 @@ export const daytonaPlayRunnerBackend: PlayRunnerBackend = {
             // classification below decide fresh-sandbox retry vs loud failure.
             throw error;
           }
+          await Promise.race([
+            confirmDetachedDaytonaRunnerReady({
+              sandbox,
+              sessionId: start.sessionId,
+              cmdId: start.cmdId,
+              readyPath: stagedPayload.readyPath,
+              exitCodePath: stagedPayload.exitCodePath,
+            }),
+            cancellationPromise,
+          ]);
           const runnerAttempt = Math.max(
             0,
             Math.floor(config.context.runAttempt ?? 0),
@@ -758,52 +767,6 @@ export const daytonaPlayRunnerBackend: PlayRunnerBackend = {
             exitCodePath: stagedPayload.exitCodePath,
             elapsedMs: Date.now() - startedAt,
           });
-          // Daytona acknowledges an async command with only a cmdId. It does
-          // not expose a queued/running state, and the backend parks before the
-          // runner contacts the runtime sheet. During startup investigations,
-          // retain a bounded snapshot while the sandbox is still alive; the
-          // normal cancellation path otherwise deletes the only evidence.
-          // This is opt-in because it adds Daytona control-plane calls to every
-          // run. The diagnostic excludes command lines and environment values.
-          if (process.env[DAYTONA_STARTUP_TRACE_ENV] === '1') {
-            const diagnosticTimer = setTimeout(() => {
-              void inspectDetachedDaytonaStartup({
-                sandbox,
-                sessionId: start.sessionId,
-                cmdId: start.cmdId,
-                exitCodePath: stagedPayload.exitCodePath,
-              }).then(
-                (diagnostic) =>
-                  emitDaytonaStage(
-                    callbacks,
-                    config.context,
-                    'execute:startup_diagnostic',
-                    {
-                      sandboxId: sandbox.id,
-                      sessionId: start.sessionId,
-                      cmdId: start.cmdId,
-                      diagnostic,
-                      elapsedMs: Date.now() - startedAt,
-                    },
-                  ),
-                (error: unknown) =>
-                  emitDaytonaStage(
-                    callbacks,
-                    config.context,
-                    'execute:startup_diagnostic_failed',
-                    {
-                      sandboxId: sandbox.id,
-                      sessionId: start.sessionId,
-                      cmdId: start.cmdId,
-                      errorType:
-                        error instanceof Error ? error.name : 'unknown',
-                      elapsedMs: Date.now() - startedAt,
-                    },
-                  ),
-              );
-            }, DAYTONA_STARTUP_DIAGNOSTIC_DELAY_MS);
-            diagnosticTimer.unref?.();
-          }
           return {
             status: 'suspended',
             suspension: {

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

@@ -95,7 +95,7 @@ import {
   PLAY_RUNTIME_CONTRACT,
   PLAY_RUNTIME_CONTRACT_HEADER,
 } from './runtime-contract';
-import { PLAY_RUNTIME_API_COMPAT_PATH } from './runtime-api-paths';
+import { PLAY_RUNTIME_API_CURRENT_PATH } from './runtime-api-paths';
 import {
   PLAY_RUNTIME_SHEET_ATTEMPT_LEASE_TTL_MS,
   PLAY_RUNTIME_WORK_RECEIPT_LEASE_TTL_MS,
@@ -298,6 +298,7 @@ const RUNTIME_WORK_RECEIPT_LEASE_COLUMNS = [
   'lease_expires_at',
 ] as const;
 const RUNTIME_WORK_RECEIPT_FAILURE_KIND_COLUMN = 'failure_kind';
+const RUNTIME_WORK_RECEIPT_KEY_INDEX = 'idx_deepline_step_receipts_k_unique';
 const RUNTIME_WORK_RECEIPT_SELF_HEAL_COLUMNS = [
   ...RUNTIME_WORK_RECEIPT_LEASE_COLUMNS,
   RUNTIME_WORK_RECEIPT_FAILURE_KIND_COLUMN,
@@ -504,7 +505,7 @@ function resolveRuntimeApiUrl(context: RuntimeApiContext): string {
   if (!baseUrl) {
     throw new Error('Runner runtime API requires a baseUrl.');
   }
-  return `${baseUrl.replace(/\/$/, '')}${PLAY_RUNTIME_API_COMPAT_PATH}`;
+  return `${baseUrl.replace(/\/$/, '')}${PLAY_RUNTIME_API_CURRENT_PATH}`;
 }
 
 function resolveRuntimeApiHeaders(
@@ -586,11 +587,13 @@ async function postRuntimeApi<TResponse>(
         ? parsed.retry_after_ms
         : RUNTIME_API_DEFAULT_RETRY_AFTER_MS;
     const details =
-      typeof parsed?.details === 'string'
-        ? parsed.details
-        : typeof parsed?.debug_error === 'string'
-          ? parsed.debug_error
-          : null;
+      typeof parsed?.detail === 'string'
+        ? parsed.detail
+        : typeof parsed?.details === 'string'
+          ? parsed.details
+          : typeof parsed?.debug_error === 'string'
+            ? parsed.debug_error
+            : null;
     const shouldRetryRuntimeResponse =
       (response.status === 503 &&
         parsed?.code === 'ingestion_plane_not_ready') ||
@@ -2040,6 +2043,22 @@ function isMissingRuntimeWorkReceiptSelfHealColumnError(
   );
 }
 
+function isMissingRuntimeWorkReceiptKeyConstraintError(
+  error: unknown,
+): boolean {
+  if (!error || typeof error !== 'object') {
+    return false;
+  }
+  const code = 'code' in error ? String(error.code) : '';
+  const message = 'message' in error ? String(error.message) : '';
+  return (
+    code === '42P10' ||
+    /no unique or exclusion constraint matching the ON CONFLICT specification/i.test(
+      message,
+    )
+  );
+}
+
 function runtimeWorkReceiptEnsureCacheKey(
   session: RuntimePostgresSession,
 ): string {
@@ -2119,22 +2138,29 @@ async function ensureRuntimeWorkReceiptTable(
         session,
         client,
       );
-      if (missingColumns.length === 0) return;
+      if (missingColumns.length > 0) {
+        await client.query(`
+          ALTER TABLE ${workReceiptTable(session)}
+            ${missingColumns
+              .map((column) => {
+                const type =
+                  column === 'lease_expires_at'
+                    ? 'timestamptz'
+                    : column === 'lease_owner_attempt'
+                      ? 'integer'
+                      : column === RUNTIME_WORK_RECEIPT_FAILURE_KIND_COLUMN
+                        ? 'smallint NOT NULL DEFAULT 0'
+                        : 'text';
+                return `ADD COLUMN IF NOT EXISTS ${column} ${type}`;
+              })
+              .join(',\n          ')}
+        `);
+      }
       await client.query(`
-        ALTER TABLE ${workReceiptTable(session)}
-          ${missingColumns
-            .map((column) => {
-              const type =
-                column === 'lease_expires_at'
-                  ? 'timestamptz'
-                  : column === 'lease_owner_attempt'
-                    ? 'integer'
-                    : column === RUNTIME_WORK_RECEIPT_FAILURE_KIND_COLUMN
-                      ? 'smallint NOT NULL DEFAULT 0'
-                      : 'text';
-              return `ADD COLUMN IF NOT EXISTS ${column} ${type}`;
-            })
-            .join(',\n          ')}
+        CREATE UNIQUE INDEX IF NOT EXISTS ${quoteIdentifier(
+          RUNTIME_WORK_RECEIPT_KEY_INDEX,
+        )}
+        ON ${workReceiptTable(session)} (k)
       `);
     })
     .then(() => undefined);
@@ -2238,7 +2264,8 @@ async function withRuntimeWorkReceiptClient<T>(
     } catch (error) {
       if (
         isMissingRelationError(error) ||
-        isMissingRuntimeWorkReceiptSelfHealColumnError(error)
+        isMissingRuntimeWorkReceiptSelfHealColumnError(error) ||
+        isMissingRuntimeWorkReceiptKeyConstraintError(error)
       ) {
         runtimeWorkReceiptEnsureCache.delete(
           runtimeWorkReceiptEnsureCacheKey(session),
@@ -4636,6 +4663,7 @@ export async function completeRuntimeWorkReceipt(
     runAttempt?: number | null;
     leaseId?: string | null;
     output: unknown;
+    returnOutput?: boolean;
   },
 ): Promise<WorkReceipt | null> {
   if (
@@ -4741,7 +4769,7 @@ export async function completeRuntimeWorkReceipt(
             })}
 	          RETURNING convert_from(k, 'UTF8') AS k,
 	                    status,
-	                    output,
+	                    CASE WHEN $7::boolean THEN output ELSE NULL::jsonb END AS output,
 	                    error,
 	                    failure_kind,
 	                    run_id,
@@ -4754,7 +4782,7 @@ export async function completeRuntimeWorkReceipt(
 	        replay AS (
 	          SELECT convert_from(k, 'UTF8') AS k,
 	                 status,
-	                 output,
+	                 CASE WHEN $7::boolean THEN output ELSE NULL::jsonb END AS output,
 	                 error,
 	                 failure_kind,
 	                 run_id,
@@ -4783,6 +4811,7 @@ export async function completeRuntimeWorkReceipt(
           input.runId,
           leaseId,
           runAttempt,
+          input.returnOutput !== false,
         ],
       );
       return rows[0] ? mapRuntimeWorkReceiptRow(rows[0]) : null;
@@ -4801,6 +4830,7 @@ export async function completeRuntimeWorkReceipts(
       leaseId?: string | null;
       runAttempt?: number | null;
     }>;
+    returnOutput?: boolean;
   },
 ): Promise<Array<WorkReceipt | null>> {
   const receipts = input.receipts.filter((receipt) => receipt.key.trim());
@@ -4819,6 +4849,7 @@ export async function completeRuntimeWorkReceipts(
         await completeRuntimeWorkReceipts(context, {
           playName: input.playName,
           receipts: siblingReceipts,
+          returnOutput: input.returnOutput,
         });
       } catch (error) {
         siblingError = error;
@@ -4938,7 +4969,7 @@ export async function completeRuntimeWorkReceipts(
            })}
         RETURNING target.k,
                   target.status,
-	                  target.output,
+	                  CASE WHEN $7::boolean THEN target.output ELSE NULL::jsonb END AS output,
 	                  target.error,
 	                  target.failure_kind,
 	                  target.run_id,
@@ -4952,7 +4983,7 @@ export async function completeRuntimeWorkReceipts(
       replay AS (
         SELECT target.k,
                target.status,
-               target.output,
+               CASE WHEN $7::boolean THEN target.output ELSE NULL::jsonb END AS output,
                target.error,
                target.failure_kind,
                target.run_id,
@@ -5020,6 +5051,7 @@ export async function completeRuntimeWorkReceipts(
             ),
           ),
           RECEIPT_STATUS_COMPLETED,
+          input.returnOutput !== false,
         ],
       );
       return rows.map((row) =>

package/dist/bundling-sources/shared_libs/play-runtime/runtime-contract.ts

@@ -1,8 +1,15 @@
-export const PLAY_RUNTIME_CONTRACT = 2;
+export const PLAY_RUNTIME_CONTRACT = 3;
 export const PLAY_RUNTIME_CONTRACT_MIN_SUPPORTED = 1;
 export const PLAY_RUNTIME_CONTRACT_HEADER = 'x-deepline-runtime-contract';
 
 export const RUNTIME_CONTRACT_CHANGELOG = [
+  {
+    contract: 3,
+    changed:
+      'Runtime receipt completion responses are compact acknowledgements; receipt reads remain the payload replay path.',
+    compatOwner: 'runtime',
+    compatRemoval: 'contract 2 support window closure',
+  },
   {
     contract: 2,
     changed:
@@ -12,6 +19,15 @@ export const RUNTIME_CONTRACT_CHANGELOG = [
   },
 ] as const;
 
+export function runtimeReceiptCompletionResponse<
+  T extends { output?: unknown },
+>(runtimeContract: number | null | undefined, receipt: T | null): T | null {
+  if (!receipt || (runtimeContract ?? 1) < 3) return receipt;
+  const { output, ...ack } = receipt;
+  void output;
+  return ack as T;
+}
+
 export type RuntimeContractResolution =
   | { ok: true; contract: number }
   | {

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

@@ -4,8 +4,9 @@
  * One of three pluggable axes (alongside runner-backends and dedup-backends).
  * Selected per-run via PlayExecutionProfile.
  *
- * Absurd is the default production scheduler through the absurd profile.
- * Cloudflare Workflows remains available through the workers_edge profile.
+ * Absurd is the enabled production scheduler. The Cloudflare Workflows
+ * adapter is retained for historical run interpretation while workers_edge
+ * launch admission is disabled.
  *
  * Customer plays are unaffected — this is purely the orchestration layer.
  */

package/dist/bundling-sources/shared_libs/play-runtime/secret-redaction.ts

@@ -5,10 +5,18 @@ const JWT_RE =
   /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\b/g;
 const PRIVATE_KEY_RE =
   /-----BEGIN [A-Z0-9 ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z0-9 ]*PRIVATE KEY-----/g;
+// Only redact self-identifying credential prefixes here. Generic words such as
+// `key`, `token`, and `secret` are common in harmless play/run slugs (for
+// example `absurd-key-rotation-check`) and need an assignment context before
+// they are sensitive; HIGH_ENTROPY_ASSIGNMENT_RE handles that case below.
 const COMMON_SECRET_RE =
-  /\b(?:sk|pk|rk|pat|ghp|github_pat|xox[baprs]|key|token|secret|api[_-]?key)[A-Za-z0-9_./+=:-]{12,}\b/gi;
+  /\b(?:sk|pk|rk|pat|ghp|github_pat|xox[baprs])[A-Za-z0-9_./+=:-]{12,}\b/gi;
+const GENERIC_PREFIXED_SECRET_RE =
+  /\b(?:key|token|secret|api[_-]?key)_[A-Za-z0-9_./+=:-]{12,}\b/gi;
 const URL_SECRET_VALUE_RE =
   /\b(?:sk|pk|rk|pat|ghp|github_pat|xox)[A-Za-z0-9_./+=:-]{12,}\b/i;
+const GENERIC_SECRET_ASSIGNMENT_RE =
+  /\b(?:api[_-]?key|token|secret|password)\b\s*[:=]\s*["']?[^"',\s]{12,}["']?/gi;
 const HIGH_ENTROPY_ASSIGNMENT_RE =
   /\b(?:api[_-]?key|token|secret|password|authorization|access[_-]?token|refresh[_-]?token)\b\s*[:=]\s*["']?[^"',\s]{16,}["']?/gi;
 const SENSITIVE_URL_PARAM_RE =
@@ -39,6 +47,8 @@ export function redactSecretLikeString(value: string): string {
     .replace(BEARER_TOKEN_RE, `Bearer ${SECRET_REDACTION_PLACEHOLDER}`)
     .replace(JWT_RE, SECRET_REDACTION_PLACEHOLDER)
     .replace(COMMON_SECRET_RE, SECRET_REDACTION_PLACEHOLDER)
+    .replace(GENERIC_PREFIXED_SECRET_RE, SECRET_REDACTION_PLACEHOLDER)
+    .replace(GENERIC_SECRET_ASSIGNMENT_RE, SECRET_REDACTION_PLACEHOLDER)
     .replace(HIGH_ENTROPY_ASSIGNMENT_RE, (match) => {
       const separator = match.includes('=') ? '=' : ':';
       const [key] = match.split(separator, 1);

package/dist/bundling-sources/shared_libs/play-runtime/transient-service-error.ts

@@ -0,0 +1,10 @@
+export function transientServiceUnavailableDetail(
+  error: unknown,
+): string | null {
+  const detail = error instanceof Error ? error.message : String(error);
+  return /ServiceUnavailable|Service temporarily unavailable|temporarily unavailable \(Code:\s*\d+\)/i.test(
+    detail,
+  )
+    ? detail
+    : null;
+}