deepline 0.3.333 → 0.3.335

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

@@ -477,7 +477,7 @@ export type CsvOptions = PlayAuthoringCsvOptions;
  *   // Emit a log line (visible in `play tail`)
  *   ctx.log(`Loaded ${await leads.count()} leads`);
  *
- *   // Pause execution
+ *   // Wait at least one second before continuing.
  *   await ctx.sleep(1000);
  *
  *   // Access submitted input through the handler's second argument.

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.333',
+  version: '0.3.335',
   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/context.ts

@@ -493,6 +493,7 @@ import {
   createRuntimeSheetDatasetPageReader,
   readRuntimeSheetDatasetRowKeys,
   RuntimeSheetAttemptSupersededError,
+  type RuntimeSheetDatasetPageReader,
 } from './runtime-api';
 import { executionGatewayDecodedBodyBytes } from './execution-gateway-response-size';
 import {
@@ -654,6 +655,7 @@ const TOOL_RETRY_AFTER_FALLBACK_MS = 1_000;
 export const TOOL_EXECUTE_RESPONSE_BODY_TIMEOUT_MS = 30_000;
 const TOOL_RETRY_HEARTBEAT_INTERVAL_MS = 30_000;
 const TOOL_PROVIDER_RESIDENT_WAIT_BUDGET_MS = 5_000;
+const AUTHORED_SLEEP_RESIDENT_LIMIT_MS = 10_000;
 const DEEPLINEAGENT_TOOL_RUNTIME_TIMEOUT_MS = 15 * 60 * 1000;
 // Every runtime-API tool fetch needs a client-side deadline. Without one, a
 // stalled execute request (e.g. a credential-less call whose gateway connection
@@ -2929,6 +2931,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
    */
   private readonly persistenceLatch: RuntimePersistenceLatch =
     createRuntimePersistenceLatch();
+  private sleepMetadataPersistenceFailed = false;
   /**
    * The single source of every concurrency, budget, and pacing decision for this
    * run-attempt. Tool/play/row slots are blocking semaphores; budgets are charged
@@ -3154,6 +3157,9 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
    */
   assertNoPendingDurableSuspension(): void {
     this.#options.executionSignal?.throwIfAborted();
+    if (this.sleepMetadataPersistenceFailed) {
+      throw new RuntimePersistenceCircuitOpenError(this.persistenceLatch);
+    }
     this.assertNoSlackHitlTimeoutFailure();
     this.assertNoRowProviderBackpressure();
     if (this.pendingDurableSuspension) {
@@ -3299,6 +3305,35 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
     base64: (value: SecretValue): SecretValue => createBase64SecretValue(value),
   };
 
+  private createRuntimeSheetDatasetPageReader(
+    tableNamespace: string,
+    rowMode?: 'output' | 'all',
+  ): RuntimeSheetDatasetPageReader {
+    if (this.#options.createRuntimeSheetDatasetPageReader) {
+      return this.#options.createRuntimeSheetDatasetPageReader({
+        orgId: this.#options.orgId,
+        executorToken: this.#options.executorToken!,
+        playName: this.#options.playName!,
+        runId: this.#options.runId!,
+        tableNamespace,
+        rowMode,
+      });
+    }
+    return createRuntimeSheetDatasetPageReader({
+      context: {
+        baseUrl: this.#options.baseUrl!,
+        executorToken: this.#options.executorToken!,
+        dbSessionStrategy: this.#options.dbSessionStrategy,
+        playName: this.#options.playName!,
+        userEmail: this.#options.userEmail,
+        runId: this.#options.runId!,
+      },
+      tableNamespace,
+      runId: this.#options.runId!,
+      rowMode,
+    });
+  }
+
   constructor(options: ContextOptions) {
     this.rootRuntimeContract =
       options.artifactRuntimeContract ??
@@ -6235,7 +6270,10 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
       runningReceiptWaitMaxAttempts?: number;
       runningReceiptWaitDelayMs?: number;
       reclaimRunning?: boolean;
-      markSkipped?: (output: T) => Promise<void> | void;
+      markSkipped?: (
+        output: T,
+        receipt: RuntimeStepReceipt,
+      ) => Promise<void> | void;
       onRecovered?: (
         output: T,
         receipt: RuntimeStepReceipt,
@@ -9009,18 +9047,8 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
         at: Date.now(),
       });
 
-      const runtimeBackedMapPageReader = createRuntimeSheetDatasetPageReader({
-        context: {
-          baseUrl: this.#options.baseUrl!,
-          executorToken: this.#options.executorToken!,
-          dbSessionStrategy: this.#options.dbSessionStrategy,
-          playName: this.#options.playName!,
-          userEmail: this.#options.userEmail,
-          runId: this.#options.runId!,
-        },
-        tableNamespace: resolvedTableNamespace,
-        runId: this.#options.runId!,
-      });
+      const runtimeBackedMapPageReader =
+        this.createRuntimeSheetDatasetPageReader(resolvedTableNamespace);
       const readRuntimeBackedMapRows = async (input: {
         limit: number;
         offset: number;
@@ -9750,19 +9778,10 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
       // Output mode selects enriched rows when this replay's earlier
       // invocation also persisted isolated failures.
       const finalizationRowMode = resumedPendingRowsOnly ? 'output' : 'all';
-      const finalizationPageReader = createRuntimeSheetDatasetPageReader({
-        context: {
-          baseUrl: this.#options.baseUrl!,
-          executorToken: this.#options.executorToken!,
-          dbSessionStrategy: this.#options.dbSessionStrategy,
-          playName: this.#options.playName!,
-          userEmail: this.#options.userEmail,
-          runId: this.#options.runId!,
-        },
-        tableNamespace: resolvedTableNamespace,
-        runId: this.#options.runId!,
-        rowMode: finalizationRowMode,
-      });
+      const finalizationPageReader = this.createRuntimeSheetDatasetPageReader(
+        resolvedTableNamespace,
+        finalizationRowMode,
+      );
       results = await reconcileNodeRuntimeMapResultsWithPersistedSheet({
         mapName: normalizedMapNamespace,
         tableNamespace: resolvedTableNamespace,
@@ -9833,18 +9852,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
         this.#options.runId,
       );
     const fullPersistedPageReader = runtimeSheetBacked
-      ? createRuntimeSheetDatasetPageReader({
-          context: {
-            baseUrl: this.#options.baseUrl!,
-            executorToken: this.#options.executorToken!,
-            dbSessionStrategy: this.#options.dbSessionStrategy,
-            playName: this.#options.playName!,
-            userEmail: this.#options.userEmail,
-            runId: this.#options.runId!,
-          },
-          tableNamespace: resolvedTableNamespace,
-          runId: this.#options.runId!,
-        })
+      ? this.createRuntimeSheetDatasetPageReader(resolvedTableNamespace)
       : null;
     const materializeFullPersistedMapRows = async (limit?: number) => {
       if (!runtimeSheetBacked) {
@@ -10744,9 +10752,14 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
             return [
               {
                 inputIndex: executionRowIndex(index),
-                data: this.toPersistedOutputRow(
-                  this.toOutputRow(item as Record<string, unknown>),
-                ),
+                // Checkpoint replay must keep the admitted identity even
+                // when restored output columns change the default row hash.
+                data: {
+                  ...this.toPersistedOutputRow(
+                    this.toOutputRow(item as Record<string, unknown>),
+                  ),
+                  ...mapRowOutcomeRuntimeFields({ key: rowKey }),
+                },
                 ...(runtimeOptions?.authoredInputDigests?.[index]
                   ? {
                       authoredInputDigest:
@@ -11147,7 +11160,14 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
               return [
                 {
                   inputIndex: executionRowIndex(index),
-                  data: this.toPersistedOutputRow(baseRow),
+                  // Preserve the admitted key rather than rehashing the
+                  // waiting row after persisted output fields are restored.
+                  data: {
+                    ...this.toPersistedOutputRow(baseRow),
+                    ...mapRowOutcomeRuntimeFields({
+                      key: keyForIndex(index),
+                    }),
+                  },
                   ...(runtimeOptions?.authoredInputDigests?.[index]
                     ? {
                         authoredInputDigest:
@@ -14581,6 +14601,111 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
     this.suspendDurably({ kind: 'sleep', boundaryId, delayMs });
   }
 
+  private sleepMetadataReceiptKey(
+    boundaryId: string,
+    intent: 'wake' | 'count',
+  ): string {
+    return durableCtxKey({
+      orgId: this.#options.orgId,
+      playId: this.currentExecutionScope.receipt.namespace,
+      operation: 'step',
+      id: `__deepline_sleep_${intent}__`,
+      semanticKey: stableStringify({
+        runId: this.currentReceiptOwnerRunId,
+        boundaryId,
+      }),
+    });
+  }
+
+  private async readStepSleepCount(boundaryId: string): Promise<number | null> {
+    try {
+      const receipt = await this.getRuntimeStepReceipt(
+        this.sleepMetadataReceiptKey(boundaryId, 'count'),
+      );
+      if (receipt?.status !== 'completed') return null;
+      const output = receipt.output;
+      const sleepCount =
+        output && typeof output === 'object' && 'sleepCount' in output
+          ? output.sleepCount
+          : undefined;
+      if (
+        typeof sleepCount !== 'number' ||
+        !Number.isSafeInteger(sleepCount) ||
+        sleepCount < 0
+      ) {
+        throw new Error(`Durable step ${boundaryId} has no valid sleep count.`);
+      }
+      return sleepCount;
+    } catch (error) {
+      this.sleepMetadataPersistenceFailed = true;
+      tripRuntimePersistenceLatch(this.persistenceLatch, error);
+      throw error;
+    }
+  }
+
+  private async persistStepSleepCount(
+    boundaryId: string,
+    sleepCount: number,
+  ): Promise<void> {
+    try {
+      await this.completeRuntimeStepReceipt(
+        this.sleepMetadataReceiptKey(boundaryId, 'count'),
+        this.currentReceiptOwnerRunId,
+        { sleepCount },
+        COMPLETED_RECEIPT_CACHE_INSERT_LEASE_ID,
+      );
+      if ((await this.readStepSleepCount(boundaryId)) === null) {
+        throw new Error(
+          `Durable step ${boundaryId} did not persist its sleep count.`,
+        );
+      }
+    } catch (error) {
+      this.sleepMetadataPersistenceFailed = true;
+      tripRuntimePersistenceLatch(this.persistenceLatch, error);
+      throw error;
+    }
+  }
+
+  private async resolveCanonicalSleepWakeAtMs(
+    boundaryId: string,
+    delayMs: number,
+  ): Promise<number> {
+    const key = this.sleepMetadataReceiptKey(boundaryId, 'wake');
+    const proposedWakeAtMs = Date.now() + delayMs;
+    try {
+      let receipt = await this.getRuntimeStepReceipt(key);
+      if (receipt?.status !== 'completed') {
+        await this.completeRuntimeStepReceipt(
+          key,
+          this.currentReceiptOwnerRunId,
+          { wakeAtMs: proposedWakeAtMs },
+          COMPLETED_RECEIPT_CACHE_INSERT_LEASE_ID,
+        );
+        receipt = await this.getRuntimeStepReceipt(key);
+      }
+      const output = receipt?.output;
+      const wakeAtMs =
+        output && typeof output === 'object' && 'wakeAtMs' in output
+          ? output.wakeAtMs
+          : undefined;
+      if (
+        receipt?.status !== 'completed' ||
+        typeof wakeAtMs !== 'number' ||
+        !Number.isSafeInteger(wakeAtMs) ||
+        wakeAtMs < 0
+      ) {
+        throw new Error(
+          `Durable sleep intent ${boundaryId} has no valid wake timestamp.`,
+        );
+      }
+      return wakeAtMs;
+    } catch (error) {
+      this.sleepMetadataPersistenceFailed = true;
+      tripRuntimePersistenceLatch(this.persistenceLatch, error);
+      throw error;
+    }
+  }
+
   async sleep(ms: number): Promise<void> {
     if (!rowContext.getStore()) this.assertRowAdmissionOpen();
     this.assertNoPendingDurableSuspension();
@@ -14654,17 +14779,49 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
       if (existing?.kind === 'sleep' && existing.completedAt !== undefined) {
         return;
       }
+      const wakeAtMs =
+        existing?.kind === 'sleep' && existing.wakeAtMs !== undefined
+          ? existing.wakeAtMs
+          : this.durableDirectToolResultsBackedByReceipts
+            ? await this.resolveCanonicalSleepWakeAtMs(boundaryId, delayMs)
+            : undefined;
+      this.assertNoPendingDurableSuspension();
       this.checkpoint.resolvedBoundaries = {
         ...(this.checkpoint.resolvedBoundaries ?? {}),
         [boundaryId]: {
+          ...existing,
           kind: 'sleep',
           delayMs,
+          ...(wakeAtMs !== undefined ? { wakeAtMs } : {}),
         },
       };
+      if (
+        wakeAtMs !== undefined &&
+        !rowStore &&
+        this.durableDirectToolResultsBackedByReceipts &&
+        (wakeAtMs <= Date.now() ||
+          (delayMs <= AUTHORED_SLEEP_RESIDENT_LIMIT_MS &&
+            wakeAtMs < (this.#options.executionDrainAtMs ?? Infinity)))
+      ) {
+        const remainingMs = Math.max(0, wakeAtMs - Date.now());
+        if (remainingMs > 0)
+          await this.sleepWithCheckpointHeartbeat(remainingMs);
+        this.assertNoPendingDurableSuspension();
+        this.checkpoint.resolvedBoundaries[boundaryId] = {
+          ...this.checkpoint.resolvedBoundaries[boundaryId],
+          kind: 'sleep',
+          delayMs,
+          wakeAtMs,
+          completedAt: Date.now(),
+        };
+        this.#options.onBatchComplete?.(this.checkpoint);
+        return;
+      }
       this.suspendDurably({
         kind: 'sleep',
         boundaryId,
         delayMs,
+        ...(wakeAtMs !== undefined ? { wakeAtMs } : {}),
       });
     }
     return new Promise((resolve) => setTimeout(resolve, delayMs));
@@ -15001,30 +15158,33 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
     const boundaryId = this.durableBoundaryId(
       `step-${scope}:${normalizedKey}${boundarySuffix}`,
     );
+    const advanceRecoveredSleepCursor = async (
+      receipt?: RuntimeStepReceipt,
+    ) => {
+      if (rowStore?.replayCallIndexes?.recoverStep(boundaryId)) return;
+      const existing = assertKnownResolvedBoundary(
+        boundaryId,
+        this.checkpoint.resolvedBoundaries?.[boundaryId],
+      );
+      const sleepCount =
+        existing?.kind === 'step' && existing.sleepCount !== undefined
+          ? existing.sleepCount
+          : receipt?.runId === this.currentReceiptOwnerRunId
+            ? ((await this.readStepSleepCount(boundaryId)) ?? 0)
+            : 0;
+      if (Number.isSafeInteger(sleepCount) && sleepCount > 0)
+        this.sleepBoundaryIndex += sleepCount;
+    };
     const executeStep = async (): Promise<T> => {
       const existing = assertKnownResolvedBoundary(
         boundaryId,
         this.checkpoint.resolvedBoundaries?.[boundaryId],
       );
       if (existing?.kind === 'step' && 'output' in existing) {
-        const replayedCalls =
-          rowStore?.replayCallIndexes?.recoverStep(boundaryId) ?? false;
         this.runtimeLog(
           `ctx.step(${normalizedKey}): recovered result from checkpoint`,
         );
-        // The step callback is not evaluated on replay, so any sleeps that it
-        // contained would otherwise disappear from the positional sleep
-        // cursor. Preserve the authored boundary sequence before evaluating
-        // the next sibling operation. This is deliberately run-local state;
-        // it is not a cross-run sleep cache or an input-derived identity.
-        if (
-          !replayedCalls &&
-          Number.isSafeInteger(existing.sleepCount) &&
-          existing.sleepCount !== undefined &&
-          existing.sleepCount > 0
-        ) {
-          this.sleepBoundaryIndex += existing.sleepCount;
-        }
+        await advanceRecoveredSleepCursor();
         return existing.output as T;
       }
 
@@ -15047,15 +15207,20 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
       // publish an enclosing step fallback that would make a later resume skip
       // the suspended work.
       this.assertNoPendingDurableSuspension();
+      const sleepCount = rowStore?.replayCallIndexes
+        ? (callAdvances.get('sleep:legacy') ?? 0)
+        : this.sleepBoundaryIndex - sleepBoundaryIndexBefore;
+      if (sleepCount > 0 && this.durableDirectToolResultsBackedByReceipts) {
+        await this.persistStepSleepCount(boundaryId, sleepCount);
+      }
+      this.assertNoPendingDurableSuspension();
       this.checkpoint.resolvedBoundaries = {
         ...(this.checkpoint.resolvedBoundaries ?? {}),
         [boundaryId]: {
           kind: 'step',
           stepId: normalizedKey,
           output,
-          sleepCount: rowStore?.replayCallIndexes
-            ? (callAdvances.get('sleep:legacy') ?? 0)
-            : this.sleepBoundaryIndex - sleepBoundaryIndexBefore,
+          sleepCount,
           completedAt: Date.now(),
         },
       };
@@ -15100,8 +15265,9 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
                 : options?.semanticKey,
               staleAfterSeconds: options?.staleAfterSeconds,
               force: this.#options.cachePolicy?.forceStepRefresh === true,
-              markSkipped: (output) => {
+              markSkipped: async (output, receipt) => {
                 assertJsonSerializableStepOutput(normalizedKey, output);
+                await advanceRecoveredSleepCursor(receipt);
               },
               execute: executeStep,
             },

package/dist/bundling-sources/shared_libs/play-runtime/ctx-types.ts

@@ -12,6 +12,7 @@ import type { PlayDatasetColumnTypes } from '../play-data-plane/contracts';
 import type { PlayStructuredDefinition } from '../plays/definition';
 import type { PlayStaticPipeline } from '../plays/static-pipeline';
 import type { PlayLogContext, PlayLogMetadata } from './log-context';
+import type { RuntimeSheetDatasetPageReader } from './runtime-api';
 import type {
   AsyncPlayRunRef,
   DurableCallStaleAfterSeconds,
@@ -772,6 +773,15 @@ export type IntegrationEventWaitHandler = {
   suspendAfterTimeoutMs?: number;
 };
 
+export type RuntimeSheetDatasetPageReaderScope = {
+  orgId?: string;
+  executorToken: string;
+  playName: string;
+  runId: string;
+  tableNamespace: string;
+  rowMode?: 'output' | 'all';
+};
+
 export interface ContextOptions {
   /**
    * Immutable worker projection resolved once from the admitted Play artifact.
@@ -815,11 +825,17 @@ export interface ContextOptions {
   rowAdmissionSignal?: AbortSignal;
   /** Local runner cancellation; never serialized into a Play artifact. */
   executionSignal?: AbortSignal;
+  /** Runner-local deadline for stopping new work, captured when its timer arms. */
+  executionDrainAtMs?: number;
   /**
    * Runtime-sheet transport selected by the runner. Daytona sandboxes use the
    * execution gateway and must never fall back to minting direct DB sessions.
    */
   dbSessionStrategy?: 'preloaded' | 'gateway_only' | 'trusted_dynamic';
+  /** Runner-owned reader; scoped database authority stays outside authored code. */
+  createRuntimeSheetDatasetPageReader?: (
+    scope: RuntimeSheetDatasetPageReaderScope,
+  ) => RuntimeSheetDatasetPageReader;
   vercelProtectionBypassToken?: string | null;
   /** Optional per-run integration execution mode for provider calls. */
   integrationMode?: 'live' | 'eval_stub' | 'fixture';
@@ -1244,6 +1260,8 @@ export interface PlayCheckpoint {
     | {
         kind: 'sleep';
         delayMs: number;
+        /** Original wake deadline. Historical boundaries retain relative waits. */
+        wakeAtMs?: number;
         completedAt?: number;
         scope?: {
           type: 'workflow' | 'map_row';

package/dist/bundling-sources/shared_libs/play-runtime/durable-receipt-execution.ts

@@ -777,7 +777,10 @@ export async function executeWithDurableRuntimeReceipt<T>(input: {
   runningReceiptWaitMaxAttempts?: number;
   runningReceiptWaitDelayMs?: number;
   reclaimRunning?: boolean;
-  markSkipped?: (output: T) => Promise<void> | void;
+  markSkipped?: (
+    output: T,
+    receipt: RuntimeStepReceipt,
+  ) => Promise<void> | void;
   onRecovered?: (
     output: T,
     receipt: RuntimeStepReceipt,
@@ -812,6 +815,9 @@ export async function executeWithDurableRuntimeReceipt<T>(input: {
   ): Promise<T> => {
     input.log(`ctx.${input.operation}(${input.id}): reused completed work`);
     if (receipt.output === undefined) {
+      if (input.operation === 'step' && input.markSkipped) {
+        await input.markSkipped(receipt.output as T, receipt);
+      }
       return receipt.output as T;
     }
     const output = runtimeReceiptOutput<T>(receipt);
@@ -819,7 +825,7 @@ export async function executeWithDurableRuntimeReceipt<T>(input: {
       ? input.onRecovered(output, receipt, 'cache')
       : output;
     if (input.markSkipped) {
-      await input.markSkipped(recovered);
+      await input.markSkipped(recovered, receipt);
     }
     return recovered;
   };

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

@@ -87,6 +87,7 @@ import { getPlayRuntimeBatchStrategy } from '../play-runtime-batching-registry';
 import type { ToolResultMetadataInput } from '../tool-result';
 import type {
   ContextOptions,
+  RuntimeSheetDatasetPageReaderScope,
   IntegrationEventWaitBoundary,
   IntegrationEventWaitHandler,
   IntegrationEventWaitRuntimeContext,
@@ -121,6 +122,8 @@ import {
 import {
   resolveRuntimeReferencedPlay,
   createCompleteRuntimeMapRowsOperation,
+  createRuntimeSheetDatasetPageReader,
+  type RuntimeSheetDatasetPageReader,
   readRuntimeSheetDatasetRowKeys,
   readRuntimeSheetDatasetRows,
   releaseRuntimeWorkReceipts,
@@ -1159,6 +1162,7 @@ export interface ExecutePlayRunnerOptions {
   signal?: AbortSignal;
   /** Stops future row admission while already admitted rows can persist. */
   rowAdmissionSignal?: AbortSignal;
+  executionDrainAtMs?: number;
   /** Runner-local terminal state made available to the deadline drain. */
   onRuntimeReady?: (runtime: {
     log: (line: string) => void;
@@ -1318,6 +1322,48 @@ export function assertPlayRunnerRuntimeSheetPersistenceContext(
   }
 }
 
+/** Keep launch-scoped database authority in the runner that admitted it. */
+export function createPlayRunnerRuntimeSheetDatasetPageReader(input: {
+  context: PlayRunnerExecutionConfig['context'];
+  preloadedDbSessions: PlayRunnerExecutionConfig['context']['preloadedDbSessions'];
+  postgresSessionUnwrapKey: string | null;
+  abortSignal: AbortSignal;
+  scope: RuntimeSheetDatasetPageReaderScope;
+}): RuntimeSheetDatasetPageReader {
+  const { context, scope } = input;
+  assertPlayRunnerRuntimeSheetPersistenceContext(context);
+  const rootRunId = context.runId ?? context.workflowId;
+  if (
+    scope.orgId !== context.orgId ||
+    scope.playName !== context.playName ||
+    scope.runId !== rootRunId ||
+    scope.executorToken !== context.executorToken
+  ) {
+    throw new Error(
+      'Runtime Sheet reader scope does not match the run launch authority.',
+    );
+  }
+  return createRuntimeSheetDatasetPageReader({
+    context: {
+      baseUrl: context.baseUrl,
+      executorToken: scope.executorToken,
+      orgId: scope.orgId,
+      playName: scope.playName,
+      runId: scope.runId,
+      userEmail: context.userEmail,
+      dbSessionStrategy: context.dbSessionStrategy,
+      preloadedDbSessions: input.preloadedDbSessions,
+      postgresSessionUnwrapKey: input.postgresSessionUnwrapKey,
+      vercelProtectionBypassToken: context.vercelProtectionBypassToken,
+      runtimeTestFaultHeader: context.runtimeTestFaultHeader ?? null,
+      abortSignal: input.abortSignal,
+    },
+    tableNamespace: scope.tableNamespace,
+    runId: scope.runId,
+    rowMode: scope.rowMode,
+  });
+}
+
 function collectReturnedDatasets(value: unknown): unknown[] {
   const datasets: unknown[] = [];
   const seen = new Set<unknown>();
@@ -2036,14 +2082,15 @@ async function run(
     runnerRunAttempt,
   );
   const workCounterSegmentId = randomUUID();
+  const runtimeLimitMs =
+    validatePlaySandboxRuntimeLimits(
+      config.context.sandboxRuntimeLimits ??
+        STANDARD_PLAY_SANDBOX_RUNTIME_LIMITS,
+    ).timeoutSeconds * 1_000;
   const persistenceSignal =
-    options?.signal ??
-    AbortSignal.timeout(
-      validatePlaySandboxRuntimeLimits(
-        config.context.sandboxRuntimeLimits ??
-          STANDARD_PLAY_SANDBOX_RUNTIME_LIMITS,
-      ).timeoutSeconds * 1_000,
-    );
+    options?.signal ?? AbortSignal.timeout(runtimeLimitMs);
+  const executionDrainAtMs =
+    options?.executionDrainAtMs ?? runStartedAt + runtimeLimitMs;
   const contextSetupStartedAt = Date.now();
   const getRuntimeToolMetadata = createRuntimeToolMetadataResolver(config);
   const getRuntimeToolAuthScopeDigest =
@@ -2225,6 +2272,7 @@ async function run(
     artifactRuntimeContract,
     rowAdmissionSignal: options?.rowAdmissionSignal,
     executionSignal: persistenceSignal,
+    executionDrainAtMs,
     executorToken: config.context.executorToken,
     baseUrl: config.context.baseUrl,
     // Runtime control stays on baseUrl (the receipt gateway); provider calls
@@ -2274,6 +2322,14 @@ async function run(
       }
     },
     dbSessionStrategy: config.context.dbSessionStrategy,
+    createRuntimeSheetDatasetPageReader: (scope) =>
+      createPlayRunnerRuntimeSheetDatasetPageReader({
+        context: config.context,
+        preloadedDbSessions: runtimePreloadedDbSessions,
+        postgresSessionUnwrapKey: runtimePostgresSessionUnwrapKey,
+        abortSignal: persistenceSignal,
+        scope,
+      }),
     fetchImpl: safeNodeStreamingOutboundFetch,
     vercelProtectionBypassToken: config.context.vercelProtectionBypassToken,
     orgId: config.context.orgId,
@@ -3894,6 +3950,7 @@ async function main() {
       result = await executePlayRunner(config, {
         signal: executionController.signal,
         rowAdmissionSignal: rowAdmissionController.signal,
+        executionDrainAtMs: runtimeDeadline.drainAtMs,
         onRuntimeReady: (runtime) => {
           runtimeState = runtime;
         },