deepline 0.1.153 → 0.1.154

package/dist/bundling-sources/apps/play-runner-workers/src/entry.ts

@@ -23,9 +23,8 @@
  *     compatible with the V8 isolate runtime.
  *
  * Status: experimental. First cut targets tool-basic (ctx.csv + ctx.dataset +
- * ctx.tools.execute). Plays that depend on the full ctx surface (durable sleep,
- * checkpoints, batched waterfalls, etc.) will fall back to "not implemented"
- * rather than producing wrong results — opt-in via DEEPLINE_PLAY_RUNNER_BACKEND.
+ * ctx.tools.execute). Plays that depend on unsupported ctx surface area fall
+ * back to "not implemented" rather than producing wrong results.
  */
 
 import {
@@ -83,6 +82,7 @@ import {
   type ToolExecuteResult,
   type ToolResultMetadataInput,
 } from '../../../shared_libs/play-runtime/tool-result';
+import { toolExecutionMetadataForOutcome } from '../../../shared_libs/play-runtime/tool-execution-outcome';
 import {
   TOOL_EXECUTE_RATE_LIMIT_MAX_ATTEMPTS,
   TOOL_EXECUTE_TRANSPORT_MAX_ATTEMPTS,
@@ -94,10 +94,16 @@ import type { PlayCallGovernanceSnapshot } from '../../../shared_libs/play-runti
 import type { PreloadedRuntimeDbSession } from '../../../shared_libs/play-runtime/db-session';
 import type { PlayRuntimeManifestMap } from '../../../shared_libs/plays/compiler-manifest';
 import {
+  deriveToolRequestIdentity,
   derivePlayRowIdentity,
   derivePlayRowIdentityFromKey,
-  deriveToolRequestIdentity,
 } from '../../../shared_libs/plays/row-identity';
+import {
+  buildDurableCtxCallCacheKey,
+  buildDurableToolCallAuthScopeDigest,
+  buildDurableToolCallCacheKey,
+} from '../../../shared_libs/play-runtime/durable-call-cache';
+import { buildScopedWorkReceiptKey } from '../../../shared_libs/play-runtime/work-receipts';
 import { DEDUPE_DUPLICATE_KEY_SAMPLE_CAP } from '../../../shared_libs/play-runtime/map-row-identity';
 import {
   getTopLevelPipelineSubsteps,
@@ -134,7 +140,23 @@ import {
   type WorkerDatasetHandle,
   type WorkerDatasetInput,
 } from './runtime/dataset-handles';
-import { runWorkerRuntimeReceiptBoundary } from './runtime/receipts';
+import {
+  runWorkerRuntimeReceiptBoundary,
+  type WorkerRuntimeReceipt,
+  type WorkerRuntimeReceiptClaim,
+  type WorkerRuntimeReceiptStore,
+} from './runtime/receipts';
+import {
+  RuntimeReceiptWaitTimeoutError,
+  waitForCompletedRuntimeReceipt,
+} from '../../../shared_libs/play-runtime/durable-receipt-execution';
+import type { RuntimeStepReceipt } from '../../../shared_libs/play-runtime/ctx-types';
+import {
+  canReclaimTimedOutWorkerToolReceipt,
+  markWorkerToolReceiptResultCached,
+  markWorkerToolReceiptResultExecution,
+  planWorkerToolReceiptGroups,
+} from './runtime/tool-receipts';
 // The harness stub forwards leaf calls (validation, runtime-api HTTP) into
 // the long-lived Play Harness Worker via env.HARNESS. We import the
 // `setHarnessBinding` setter eagerly so it's available the moment
@@ -222,17 +244,8 @@ import {
 import {
   DEEPLINE_CELL_META_FIELD,
   previousCellFromValue,
-  resolveCompletedCellStalenessMeta,
-  shouldRecomputeCell,
-  type AuthoredCellStalenessPolicyByField,
-  type AuthoredStaleAfterSeconds,
-  type CellStalenessPolicyByField,
   type PreviousCell,
 } from '../../../shared_libs/play-runtime/cell-staleness';
-import {
-  authoredCellPoliciesFromDatasetSteps,
-  cellPoliciesFromDatasetSteps,
-} from '../../../shared_libs/play-data-plane/cell-policy';
 
 // The play's default export. The bundler injects this — see bundle-play-file.ts.
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
@@ -335,6 +348,7 @@ type WorkerEnv = {
   RUNTIME_API?: {
     runtimeApiCall(input: {
       executorToken: string;
+      baseUrl?: string;
       path: string;
       method?: string;
       body: unknown;
@@ -553,6 +567,7 @@ async function fetchRuntimeApi(
       cachedRuntimeApiBinding,
       mergedInit,
       {
+        baseUrl,
         path,
         timeoutMs,
       },
@@ -579,7 +594,7 @@ async function fetchRuntimeApi(
 async function callRuntimeApiRpcBinding(
   binding: NonNullable<WorkerEnv['RUNTIME_API']>,
   init: RequestInit,
-  input: { path: string; timeoutMs: number },
+  input: { baseUrl: string; path: string; timeoutMs: number },
 ): Promise<Response> {
   const h = new Headers(init.headers);
   const authorization = h.get('authorization') ?? '';
@@ -591,8 +606,9 @@ async function callRuntimeApiRpcBinding(
   const rawBody = typeof init.body === 'string' ? init.body : '';
   const result = await binding.runtimeApiCall({
     executorToken: authorization.replace(/^Bearer\s+/i, '').trim(),
+    baseUrl: input.baseUrl,
     path: input.path,
-    method: init.method ?? 'POST',
+    method: init.method,
     body: rawBody ? JSON.parse(rawBody) : {},
     headers,
     timeoutMs: input.timeoutMs,
@@ -1225,6 +1241,7 @@ function normalizeToolExecuteArgs(request: unknown): {
   id: string;
   toolId: string;
   input: Record<string, unknown>;
+  force?: boolean;
   staleAfterSeconds?: number;
 } {
   if (!isToolExecuteRecord(request)) {
@@ -1247,6 +1264,7 @@ function normalizeToolExecuteArgs(request: unknown): {
     id: request.id.trim(),
     toolId: request.tool,
     input: request.input,
+    ...(request.force === true ? { force: true } : {}),
     ...(typeof request.staleAfterSeconds === 'number'
       ? { staleAfterSeconds: request.staleAfterSeconds }
       : {}),
@@ -1487,85 +1505,10 @@ function wrapWorkerToolResult(
     status,
     result,
     metadata: metadata ?? { toolId },
-    execution: {
-      idempotent: true,
-      cached: false,
-      source: 'live',
-    },
+    execution: toolExecutionMetadataForOutcome({ kind: 'live' }),
   });
 }
 
-function isRecordLike(value: unknown): value is Record<string, unknown> {
-  return value != null && typeof value === 'object' && !Array.isArray(value);
-}
-
-/**
- * True when a normalized tool result carries something the play would treat
- * as a "hit". Conservative: empty objects/arrays/strings count as misses, but
- * any non-empty primitive or any record with at least one non-nullish value
- * counts as content. Used by ctx.waterfall to decide whether to short-circuit.
- */
-function resultHasContent(value: unknown): boolean {
-  if (value == null) return false;
-  if (typeof value === 'string') return value.length > 0;
-  if (typeof value === 'number' || typeof value === 'boolean') return true;
-  if (Array.isArray(value)) return value.length > 0;
-  if (typeof value === 'object') {
-    for (const v of Object.values(value as Record<string, unknown>)) {
-      if (v == null) continue;
-      if (typeof v === 'string' && v.length === 0) continue;
-      if (Array.isArray(v) && v.length === 0) continue;
-      return true;
-    }
-    return false;
-  }
-  return true;
-}
-
-type WorkerInlineWaterfallSpec = {
-  id: string;
-  output: string;
-  minResults: number;
-  steps: Array<
-    | {
-        id: string;
-        kind?: 'tool';
-        toolId: string;
-        mapInput: (input: Record<string, unknown>) => Record<string, unknown>;
-      }
-    | {
-        id: string;
-        kind: 'code';
-        run: (
-          input: Record<string, unknown>,
-          ctx: {
-            tools: {
-              execute(request: {
-                id: string;
-                tool: string;
-                input: Record<string, unknown>;
-                description?: string;
-                staleAfterSeconds?: number;
-              }): Promise<unknown>;
-            };
-          },
-        ) => unknown | Promise<unknown>;
-      }
-  >;
-};
-
-type WorkerWaterfallOptions = {
-  providers?: string[];
-  min_results?: number;
-  description?: string;
-};
-
-type RecordedWaterfallOutput = {
-  waterfallId: string;
-  stepId: string;
-  value: unknown;
-};
-
 type RecordedStepProgramOutput = {
   field: string;
   columnName: string;
@@ -1581,6 +1524,9 @@ type WorkerStepResolution = {
 
 type WorkerToolBatchRequest = {
   id: string;
+  cacheKey: string;
+  receiptKey: string | null;
+  force: boolean;
   toolId: string;
   input: Record<string, unknown>;
   workflowStep?: WorkflowStep;
@@ -1588,6 +1534,17 @@ type WorkerToolBatchRequest = {
   reject: (error: unknown) => void;
 };
 
+type ClaimedWorkerToolBatchRequest = {
+  request: WorkerToolBatchRequest;
+  receiptKey: string | null;
+  followers: WorkerToolBatchRequest[];
+};
+
+type PreparedWorkerToolBatchRequests = {
+  claimedRequests: ClaimedWorkerToolBatchRequest[];
+  deferredClaimedRequests: Promise<ClaimedWorkerToolBatchRequest[]>[];
+};
+
 const WORKER_TOOL_BATCH_GRACE_MS = 250;
 const MAP_EXECUTION_HEARTBEAT_INTERVAL_MS = 5_000;
 const MAP_INCREMENTAL_PERSIST_CHUNK_ROWS = 100;
@@ -1604,6 +1561,7 @@ const MAP_ROW_FAILURE_SAMPLE_LIMIT = 3;
 // their previous batching behavior; declared providers tighten via the
 // Governor's suggestedParallelism.
 const WORKER_TOOL_BATCH_DEFAULT_PARALLELISM = 4;
+
 /**
  * In-process retry budget for HTTP 429 tool responses. Rate-limit pushback is
  * throughput pacing (provider or Deepline limiter), not a tool defect, so it
@@ -1617,6 +1575,43 @@ function sleepWorkerMs(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+function workerDurableToolCallCacheKey(input: {
+  req: RunRequest;
+  toolId: string;
+  requestInput: Record<string, unknown>;
+  providerActionVersion: string;
+  staleAfterSeconds?: number | null;
+}): string {
+  return buildDurableToolCallCacheKey({
+    orgId: input.req.orgId,
+    playId: input.req.playName,
+    toolId: input.toolId,
+    requestInput: input.requestInput,
+    authScopeDigest: buildDurableToolCallAuthScopeDigest({
+      orgId: input.req.orgId,
+      userEmail: input.req.userEmail,
+      toolId: input.toolId,
+    }),
+    providerActionVersion: input.providerActionVersion,
+    staleAfterSeconds: input.staleAfterSeconds,
+  });
+}
+
+function workerRuntimeReceiptKey(input: {
+  req: RunRequest;
+  key: string;
+}): string {
+  const orgId = input.req.orgId?.trim() || 'org';
+  if (input.key.startsWith(`ctx:${orgId}:`)) {
+    return input.key;
+  }
+  return buildScopedWorkReceiptKey({
+    orgId: input.req.orgId,
+    playName: input.req.playName,
+    key: input.key,
+  });
+}
+
 function stepProgramColumnName(parentField: string, stepId: string): string {
   return sqlSafePlayColumnName(`${parentField}.${stepId}`);
 }
@@ -1629,9 +1624,12 @@ class WorkerToolBatchScheduler {
     private readonly req: RunRequest,
     private readonly governor: PlayExecutionGovernor,
     private readonly resolvePacing: WorkerPacingResolver,
+    private readonly resolveToolActionCacheVersion: WorkerToolActionCacheVersionResolver,
     private readonly abortSignal?: AbortSignal,
     private readonly onRequestsSettled?: (count: number) => void,
     private readonly callbacks?: WorkerCtxCallbacks,
+    private readonly receiptStore?: WorkerRuntimeReceiptStore,
+    private readonly allowLocalRetryReceipts = false,
   ) {}
 
   /**
@@ -1653,16 +1651,29 @@ class WorkerToolBatchScheduler {
     })();
   }
 
-  execute(
+  async execute(
     id: string,
     toolId: string,
     input: Record<string, unknown>,
     workflowStep?: WorkflowStep,
+    options?: { force?: boolean; staleAfterSeconds?: number | null },
   ): Promise<unknown> {
-    return new Promise((resolve, reject) => {
+    const providerActionVersion =
+      await this.resolveToolActionCacheVersion(toolId);
+    return await new Promise((resolve, reject) => {
       const queuedAt = nowMs();
+      const receiptKey = workerDurableToolCallCacheKey({
+        req: this.req,
+        toolId,
+        requestInput: input,
+        providerActionVersion,
+        staleAfterSeconds: options?.staleAfterSeconds,
+      });
       this.queue.push({
         id,
+        cacheKey: receiptKey,
+        receiptKey,
+        force: options?.force === true,
         toolId,
         input,
         workflowStep,
@@ -1725,15 +1736,529 @@ class WorkerToolBatchScheduler {
     }
   }
 
+  private async waitForDurableToolReceipt(
+    receiptKey: string,
+  ): Promise<unknown> {
+    if (!this.receiptStore) {
+      throw new Error('Worker durable tool receipt store is not configured.');
+    }
+    if (!this.receiptStore.getReceipt) {
+      throw new Error(
+        'Worker durable tool receipt wait requires read-only receipt lookup.',
+      );
+    }
+    const receipt = await waitForCompletedRuntimeReceipt({
+      receiptKey,
+      store: {
+        getMany: async (receiptKeys) => {
+          const receipts = new Map<string, RuntimeStepReceipt>();
+          await Promise.all(
+            receiptKeys.map(async (key) => {
+              const receipt = await this.receiptStore!.getReceipt!({
+                playName: this.req.playName,
+                key,
+              });
+              if (!receipt) return;
+              receipts.set(key, {
+                key: receipt.key,
+                status: receipt.status,
+                output: receipt.output,
+                error: receipt.error ?? undefined,
+                runId: receipt.runId ?? null,
+              });
+            }),
+          );
+          return receipts;
+        },
+      },
+    });
+    return markWorkerToolReceiptResultCached(
+      deserializeDurableStepValue(receipt.output),
+      receiptKey,
+      receiptKey,
+    );
+  }
+
+  private settleRequests(
+    claimed: ClaimedWorkerToolBatchRequest,
+    result: unknown,
+  ): void {
+    claimed.request.resolve(result);
+    for (const follower of claimed.followers) {
+      follower.resolve(
+        claimed.receiptKey
+          ? markWorkerToolReceiptResultExecution(result, {
+              kind: 'in_flight',
+              receiptKey: claimed.receiptKey,
+              attachedToReceiptKey: claimed.receiptKey,
+            })
+          : result,
+      );
+    }
+    this.onRequestsSettled?.(1 + claimed.followers.length);
+  }
+
+  private rejectRequests(
+    claimed: ClaimedWorkerToolBatchRequest,
+    error: unknown,
+  ): void {
+    claimed.request.reject(error);
+    for (const follower of claimed.followers) {
+      follower.reject(error);
+    }
+    this.onRequestsSettled?.(1 + claimed.followers.length);
+  }
+
+  private rejectRawRequests(
+    requests: WorkerToolBatchRequest[],
+    error: unknown,
+  ): void {
+    for (const request of requests) {
+      request.reject(error);
+    }
+    this.onRequestsSettled?.(requests.length);
+  }
+
+  private async reclaimTimedOutDurableToolReceiptGroup(input: {
+    group: WorkerToolBatchRequest[];
+    receiptKey: string;
+    runningReceipt: WorkerRuntimeReceipt;
+    waitError: unknown;
+  }): Promise<ClaimedWorkerToolBatchRequest[]> {
+    const [request, ...followers] = input.group;
+    if (!request || !this.receiptStore) {
+      this.rejectRawRequests(input.group, input.waitError);
+      return [];
+    }
+    if (
+      !canReclaimTimedOutWorkerToolReceipt({
+        ownerRunId: input.runningReceipt.runId,
+        currentRunId: this.req.runId,
+      })
+    ) {
+      this.rejectRawRequests(input.group, input.waitError);
+      return [];
+    }
+    let claim: WorkerRuntimeReceiptClaim;
+    try {
+      claim = await this.receiptStore.claimReceipt({
+        playName: this.req.playName,
+        runId: this.req.runId,
+        key: input.receiptKey,
+        reclaimRunning: true,
+      });
+    } catch (error) {
+      this.rejectRawRequests(input.group, error);
+      return [];
+    }
+    if (claim.disposition === 'claimed') {
+      return [{ request, receiptKey: input.receiptKey, followers }];
+    }
+    if (claim.disposition === 'reused') {
+      const result = markWorkerToolReceiptResultCached(
+        deserializeDurableStepValue(claim.receipt.output),
+        request.cacheKey,
+        input.receiptKey,
+      );
+      for (const pending of input.group) {
+        pending.resolve(result);
+      }
+      this.onRequestsSettled?.(input.group.length);
+      return [];
+    }
+    if (claim.disposition === 'failed') {
+      this.rejectRawRequests(
+        input.group,
+        new Error(
+          `Durable tool call ${input.receiptKey} failed: ${claim.receipt.error ?? 'unknown error'}`,
+        ),
+      );
+      return [];
+    }
+    this.rejectRawRequests(input.group, input.waitError);
+    return [];
+  }
+
+  private async failureForRejectedToolRequest(
+    claimed: ClaimedWorkerToolBatchRequest,
+    error: unknown,
+  ): Promise<unknown> {
+    try {
+      await this.failDurableToolRequest(claimed, error);
+      return error;
+    } catch (receiptError) {
+      return new AggregateError(
+        [error, receiptError],
+        'Tool call failed and durable receipt could not be marked failed',
+      );
+    }
+  }
+
+  private async claimDurableToolReceiptGroups(
+    groups: ReturnType<
+      typeof planWorkerToolReceiptGroups<WorkerToolBatchRequest>
+    >['durableGroups'],
+  ): Promise<
+    Array<{
+      group: ReturnType<
+        typeof planWorkerToolReceiptGroups<WorkerToolBatchRequest>
+      >['durableGroups'][number];
+      receiptKey: string;
+      claim: WorkerRuntimeReceiptClaim;
+    }>
+  > {
+    if (!this.receiptStore) return [];
+    const planned = groups.map((group) => ({
+      group,
+      receiptKey: workerRuntimeReceiptKey({
+        req: this.req,
+        key: group.claimableReceiptKey,
+      }),
+    }));
+    const claimOne = async (entry: (typeof planned)[number]) => ({
+      ...entry,
+      claim: await this.receiptStore!.claimReceipt({
+        playName: this.req.playName,
+        runId: this.req.runId,
+        key: entry.receiptKey,
+        ...(entry.group.forceDurableRefresh
+          ? { forceRefresh: true, reclaimRunning: true }
+          : {}),
+      }),
+    });
+    if (!this.receiptStore.claimReceipts) {
+      return await Promise.all(planned.map(claimOne));
+    }
+    const claimed: Array<{
+      group: (typeof planned)[number]['group'];
+      receiptKey: string;
+      claim: WorkerRuntimeReceiptClaim;
+    }> = [];
+    for (const forceDurableRefresh of [false, true]) {
+      const entries = planned.filter(
+        (entry) => entry.group.forceDurableRefresh === forceDurableRefresh,
+      );
+      if (entries.length === 0) continue;
+      const claims = await this.receiptStore.claimReceipts({
+        playName: this.req.playName,
+        runId: this.req.runId,
+        keys: entries.map((entry) => entry.receiptKey),
+        ...(forceDurableRefresh
+          ? { forceRefresh: true, reclaimRunning: true }
+          : {}),
+      });
+      entries.forEach((entry, index) => {
+        const claim = claims[index];
+        if (!claim) {
+          throw new Error(
+            `Runtime receipt batch claim did not return receipt ${entry.receiptKey}.`,
+          );
+        }
+        claimed.push({ ...entry, claim });
+      });
+    }
+    return claimed;
+  }
+
+  private async prepareDurableToolRequests(
+    requests: WorkerToolBatchRequest[],
+  ): Promise<PreparedWorkerToolBatchRequests> {
+    if (!this.receiptStore) {
+      return {
+        claimedRequests: requests.map((request) => ({
+          request,
+          receiptKey: null,
+          followers: [],
+        })),
+        deferredClaimedRequests: [],
+      };
+    }
+
+    const claimedRequests: ClaimedWorkerToolBatchRequest[] = [];
+    const deferredClaimedRequests: Promise<ClaimedWorkerToolBatchRequest[]>[] =
+      [];
+    const receiptGroupPlan = planWorkerToolReceiptGroups(requests, {
+      allowLocalRetryReceipts: this.allowLocalRetryReceipts,
+      getReceiptInput: (request) => ({
+        durableReceiptKey: request.receiptKey,
+        localRetryCacheKey: request.cacheKey,
+        force: request.force,
+      }),
+    });
+    for (const request of receiptGroupPlan.localRequests) {
+      claimedRequests.push({
+        request,
+        receiptKey: null,
+        followers: [],
+      });
+    }
+
+    try {
+      const claimEntries = await this.claimDurableToolReceiptGroups(
+        receiptGroupPlan.durableGroups,
+      );
+      for (const { group: groupState, receiptKey, claim } of claimEntries) {
+        const group = groupState.requests;
+        const [first] = group;
+        if (!first) continue;
+        if (claim.disposition === 'reused') {
+          const result = markWorkerToolReceiptResultCached(
+            deserializeDurableStepValue(claim.receipt.output),
+            first.cacheKey,
+            receiptKey,
+          );
+          for (const request of group) {
+            request.resolve(result);
+          }
+          this.onRequestsSettled?.(group.length);
+          continue;
+        }
+        if (claim.disposition === 'failed') {
+          const error = new Error(
+            `Durable tool call ${receiptKey} failed: ${claim.receipt.error ?? 'unknown error'}`,
+          );
+          this.rejectRawRequests(group, error);
+          continue;
+        }
+        if (claim.disposition === 'running') {
+          deferredClaimedRequests.push(
+            (async (): Promise<ClaimedWorkerToolBatchRequest[]> => {
+              let waitError: unknown = new RuntimeReceiptWaitTimeoutError(
+                receiptKey,
+              );
+              try {
+                const result = await this.waitForDurableToolReceipt(receiptKey);
+                for (const request of group) {
+                  request.resolve(
+                    markWorkerToolReceiptResultExecution(result, {
+                      kind: 'in_flight',
+                      receiptKey,
+                      attachedToReceiptKey: receiptKey,
+                    }),
+                  );
+                }
+                this.onRequestsSettled?.(group.length);
+                return [];
+              } catch (error) {
+                waitError = error;
+                if (!(error instanceof RuntimeReceiptWaitTimeoutError)) {
+                  this.rejectRawRequests(group, error);
+                  return [];
+                }
+              }
+              return await this.reclaimTimedOutDurableToolReceiptGroup({
+                group,
+                receiptKey,
+                runningReceipt: claim.receipt,
+                waitError,
+              });
+            })(),
+          );
+          continue;
+        }
+        const [request, ...followers] = group;
+        if (!request) continue;
+        claimedRequests.push({ request, receiptKey, followers });
+      }
+    } catch (error) {
+      for (const group of receiptGroupPlan.durableGroups) {
+        this.rejectRawRequests(group.requests, error);
+      }
+    }
+    return { claimedRequests, deferredClaimedRequests };
+  }
+
+  private async completeDurableToolRequest(
+    claimed: ClaimedWorkerToolBatchRequest,
+    result: unknown,
+  ): Promise<unknown> {
+    if (!this.receiptStore || !claimed.receiptKey) {
+      return result;
+    }
+    const ownerResult = markWorkerToolReceiptResultExecution(result, {
+      kind: 'live',
+      receiptKey: claimed.receiptKey,
+    });
+    const completed = await this.receiptStore.completeReceipt({
+      playName: this.req.playName,
+      runId: this.req.runId,
+      key: claimed.receiptKey,
+      output: serializeDurableStepValue(ownerResult),
+    });
+    if (
+      completed &&
+      (completed.status === 'completed' || completed.status === 'skipped') &&
+      completed.output !== undefined
+    ) {
+      const recovered = deserializeDurableStepValue(completed.output);
+      return completed.runId && completed.runId !== this.req.runId
+        ? markWorkerToolReceiptResultCached(
+            recovered,
+            claimed.request.cacheKey,
+            claimed.receiptKey,
+          )
+        : recovered;
+    }
+    return ownerResult;
+  }
+
+  private completedDurableToolRequestResult(input: {
+    claimed: ClaimedWorkerToolBatchRequest;
+    ownerResult: unknown;
+    completed: WorkerRuntimeReceipt | null | undefined;
+  }): unknown {
+    const { claimed, completed, ownerResult } = input;
+    if (
+      completed &&
+      (completed.status === 'completed' || completed.status === 'skipped') &&
+      completed.output !== undefined
+    ) {
+      const recovered = deserializeDurableStepValue(completed.output);
+      return completed.runId && completed.runId !== this.req.runId
+        ? markWorkerToolReceiptResultCached(
+            recovered,
+            claimed.request.cacheKey,
+            claimed.receiptKey ?? claimed.request.cacheKey,
+          )
+        : recovered;
+    }
+    return ownerResult;
+  }
+
+  private async completeDurableToolRequests(
+    entries: Array<{ claimed: ClaimedWorkerToolBatchRequest; result: unknown }>,
+  ): Promise<unknown[]> {
+    const results: unknown[] = new Array(entries.length);
+    const durableEntries: Array<{
+      index: number;
+      claimed: ClaimedWorkerToolBatchRequest;
+      ownerResult: unknown;
+    }> = [];
+    for (let index = 0; index < entries.length; index += 1) {
+      const entry = entries[index]!;
+      if (!this.receiptStore || !entry.claimed.receiptKey) {
+        results[index] = entry.result;
+        continue;
+      }
+      const ownerResult = markWorkerToolReceiptResultExecution(entry.result, {
+        kind: 'live',
+        receiptKey: entry.claimed.receiptKey,
+      });
+      durableEntries.push({ index, claimed: entry.claimed, ownerResult });
+    }
+    if (durableEntries.length === 0) {
+      return results;
+    }
+    if (!this.receiptStore?.completeReceipts) {
+      await Promise.all(
+        durableEntries.map(async (entry) => {
+          results[entry.index] = await this.completeDurableToolRequest(
+            entry.claimed,
+            entries[entry.index]!.result,
+          );
+        }),
+      );
+      return results;
+    }
+    const completed = await this.receiptStore.completeReceipts({
+      playName: this.req.playName,
+      receipts: durableEntries.map((entry) => ({
+        runId: this.req.runId,
+        key: entry.claimed.receiptKey!,
+        output: serializeDurableStepValue(entry.ownerResult),
+      })),
+    });
+    durableEntries.forEach((entry, resultIndex) => {
+      results[entry.index] = this.completedDurableToolRequestResult({
+        claimed: entry.claimed,
+        ownerResult: entry.ownerResult,
+        completed: completed[resultIndex],
+      });
+    });
+    return results;
+  }
+
+  private async failDurableToolRequest(
+    claimed: ClaimedWorkerToolBatchRequest,
+    error: unknown,
+  ): Promise<void> {
+    if (!this.receiptStore || !claimed.receiptKey) {
+      return;
+    }
+    await this.receiptStore.failReceipt({
+      playName: this.req.playName,
+      runId: this.req.runId,
+      key: claimed.receiptKey,
+      error: error instanceof Error ? error.message : String(error),
+    });
+  }
+
+  private async failDurableToolRequests(
+    claimedRequests: ClaimedWorkerToolBatchRequest[],
+    error: unknown,
+  ): Promise<void> {
+    const durable = claimedRequests.filter(
+      (claimed) => this.receiptStore && claimed.receiptKey,
+    );
+    if (durable.length === 0) return;
+    if (!this.receiptStore?.failReceipts) {
+      await Promise.all(
+        durable.map((claimed) => this.failDurableToolRequest(claimed, error)),
+      );
+      return;
+    }
+    await this.receiptStore.failReceipts({
+      playName: this.req.playName,
+      receipts: durable.map((claimed) => ({
+        runId: this.req.runId,
+        key: claimed.receiptKey!,
+        error: error instanceof Error ? error.message : String(error),
+      })),
+    });
+  }
+
   private async executeToolGroup(
     toolId: string,
     requests: WorkerToolBatchRequest[],
   ): Promise<void> {
+    const { claimedRequests, deferredClaimedRequests } =
+      await this.prepareDurableToolRequests(requests);
+    await this.executeClaimedToolRequests(
+      toolId,
+      requests.length,
+      claimedRequests,
+    );
+    if (deferredClaimedRequests.length === 0) {
+      return;
+    }
+    const reclaimedRequests = (
+      await Promise.all(deferredClaimedRequests)
+    ).flat();
+    await this.executeClaimedToolRequests(
+      toolId,
+      requests.length,
+      reclaimedRequests,
+    );
+  }
+
+  private async executeClaimedToolRequests(
+    toolId: string,
+    requestCount: number,
+    claimedRequests: ClaimedWorkerToolBatchRequest[],
+  ): Promise<void> {
+    if (claimedRequests.length === 0) {
+      return;
+    }
     const strategy = getPlayRuntimeBatchStrategy(toolId);
-    if (!strategy || toolId === 'test_wait_for_event' || requests.length < 2) {
+    if (
+      !strategy ||
+      toolId === 'test_wait_for_event' ||
+      claimedRequests.length < 2
+    ) {
       const groupStartedAt = nowMs();
       await Promise.all(
-        requests.map(async (request) => {
+        claimedRequests.map(async (claimed) => {
+          const { request } = claimed;
           const toolContract = await this.resolvePacing(toolId).catch(
             () => null,
           );
@@ -1744,21 +2269,25 @@ class WorkerToolBatchScheduler {
             signal: this.abortSignal,
           });
           try {
-            request.resolve(
-              await executeToolWithLifecycle(
-                this.req,
-                { id: request.id, toolId, input: request.input },
-                request.workflowStep,
-                this.callbacks,
-                (retryAfterMs) => this.reportBackpressure(toolId, retryAfterMs),
-                () => this.governor.chargeBudget('retry'),
-                toolContract?.retrySafeTransientHttp === true,
-              ),
+            const result = await executeToolWithLifecycle(
+              this.req,
+              { id: request.id, toolId, input: request.input },
+              request.workflowStep,
+              this.callbacks,
+              (retryAfterMs) => this.reportBackpressure(toolId, retryAfterMs),
+              () => this.governor.chargeBudget('retry'),
+              toolContract?.retrySafeTransientHttp === true,
+            );
+            this.settleRequests(
+              claimed,
+              await this.completeDurableToolRequest(claimed, result),
             );
           } catch (error) {
-            request.reject(error);
+            this.rejectRequests(
+              claimed,
+              await this.failureForRejectedToolRequest(claimed, error),
+            );
           } finally {
-            this.onRequestsSettled?.(1);
             slot.release();
           }
         }),
@@ -1767,7 +2296,12 @@ class WorkerToolBatchScheduler {
         req: this.req,
         phase: 'runner.tool.group',
         ms: nowMs() - groupStartedAt,
-        extra: { toolId, requests: requests.length, batched: false },
+        extra: {
+          toolId,
+          requests: requestCount,
+          executed: claimedRequests.length,
+          batched: false,
+        },
       });
       return;
     }
@@ -1775,7 +2309,7 @@ class WorkerToolBatchScheduler {
     const batchStartedAt = nowMs();
     await executeBatchedWorkerToolGroup({
       req: this.req,
-      requests,
+      requests: claimedRequests,
       strategy,
       governor: this.governor,
       suggestedParallelism: await this.governor.suggestedParallelism(
@@ -1788,12 +2322,23 @@ class WorkerToolBatchScheduler {
       resolveToolContract: this.resolvePacing,
       onRequestsSettled: this.onRequestsSettled,
       callbacks: this.callbacks,
+      completeRequests: async (entries) =>
+        await this.completeDurableToolRequests(entries),
+      failRequests: async (claimedRequests, error) =>
+        await this.failDurableToolRequests(claimedRequests, error),
+      settleRequest: (claimed, result) => this.settleRequests(claimed, result),
+      rejectRequest: (claimed, error) => this.rejectRequests(claimed, error),
     });
     recordRunnerPerfTrace({
       req: this.req,
       phase: 'runner.tool.group',
       ms: nowMs() - batchStartedAt,
-      extra: { toolId, requests: requests.length, batched: true },
+      extra: {
+        toolId,
+        requests: requestCount,
+        executed: claimedRequests.length,
+        batched: true,
+      },
     });
   }
 }
@@ -1815,7 +2360,7 @@ function groupWorkerToolRequestsByTool(
 
 async function executeBatchedWorkerToolGroup(input: {
   req: RunRequest;
-  requests: WorkerToolBatchRequest[];
+  requests: ClaimedWorkerToolBatchRequest[];
   strategy: AnyBatchOperationStrategy;
   governor: PlayExecutionGovernor;
   suggestedParallelism: number;
@@ -1824,11 +2369,26 @@ async function executeBatchedWorkerToolGroup(input: {
   resolveToolContract: WorkerPacingResolver;
   onRequestsSettled?: (count: number) => void;
   callbacks?: WorkerCtxCallbacks;
+  completeRequests: (
+    entries: Array<{ claimed: ClaimedWorkerToolBatchRequest; result: unknown }>,
+  ) => Promise<unknown[]>;
+  failRequests: (
+    requests: ClaimedWorkerToolBatchRequest[],
+    error: unknown,
+  ) => Promise<void>;
+  settleRequest: (
+    request: ClaimedWorkerToolBatchRequest,
+    result: unknown,
+  ) => void;
+  rejectRequest: (
+    request: ClaimedWorkerToolBatchRequest,
+    error: unknown,
+  ) => void;
 }): Promise<void> {
   const compiledBatches = compileRequestsWithStrategy({
     requests: input.requests,
     strategy: input.strategy,
-    getPayload: (request) => request.input,
+    getPayload: (request) => request.request.input,
   });
   recordRunnerPerfTrace({
     req: input.req,
@@ -1865,7 +2425,7 @@ async function executeBatchedWorkerToolGroup(input: {
         return await executeTool(
           input.req,
           {
-            id: `batch:${batch.memberRequests.map((request) => request.id).join('|')}`,
+            id: `batch:${batch.memberRequests.map((request) => request.request.id).join('|')}`,
             toolId: batch.batchOperation,
             input: batch.batchPayload,
           },
@@ -1891,8 +2451,17 @@ async function executeBatchedWorkerToolGroup(input: {
           // One batch's provider error stays scoped to that batch's member
           // requests. Sibling batches in this chunk keep their results so a
           // single provider hiccup cannot cascade into a whole-map failure.
-          for (const request of entry.request.memberRequests) {
-            request.reject(entry.error);
+          let rejection: unknown = entry.error;
+          try {
+            await input.failRequests(entry.request.memberRequests, entry.error);
+          } catch (receiptError) {
+            rejection = new AggregateError(
+              [entry.error, receiptError],
+              'Tool call failed and durable receipts could not be marked failed',
+            );
+          }
+          for (const claimed of entry.request.memberRequests) {
+            input.rejectRequest(claimed, rejection);
           }
           continue;
         }
@@ -1903,60 +2472,39 @@ async function executeBatchedWorkerToolGroup(input: {
           batchResult != null
             ? entry.request.splitResults(batchResult)
             : entry.request.memberRequests.map(() => null);
-        for (
-          let index = 0;
-          index < entry.request.memberRequests.length;
-          index += 1
-        ) {
-          const request = entry.request.memberRequests[index]!;
-          request.resolve(
-            wrapWorkerToolResult(
-              request.toolId,
+        const completedResults = await input.completeRequests(
+          entry.request.memberRequests.map((claimed, index) => ({
+            claimed,
+            result: wrapWorkerToolResult(
+              claimed.request.toolId,
               splitResults[index] ?? null,
-              toolMetadataFallback(request.toolId),
+              toolMetadataFallback(claimed.request.toolId),
             ),
-          );
+          })),
+        );
+        for (let index = 0; index < completedResults.length; index += 1) {
+          const claimed = entry.request.memberRequests[index]!;
+          const request = claimed.request;
+          input.settleRequest(claimed, completedResults[index]);
         }
       }
-      const settledMembers = chunkResults.reduce(
-        (total, entry) => total + entry.request.memberRequests.length,
-        0,
-      );
-      if (settledMembers > 0) {
-        input.onRequestsSettled?.(settledMembers);
-      }
     },
-  }).catch((error) => {
-    for (const request of input.requests) {
-      request.reject(error);
+  }).catch(async (error) => {
+    let rejection: unknown = error;
+    try {
+      await input.failRequests(input.requests, error);
+    } catch (receiptError) {
+      rejection = new AggregateError(
+        [error, receiptError],
+        'Tool call failed and durable receipts could not be marked failed',
+      );
+    }
+    for (const claimed of input.requests) {
+      input.rejectRequest(claimed, rejection);
     }
   });
 }
 
-function isWorkerInlineCodeStep(
-  step: WorkerInlineWaterfallSpec['steps'][number],
-): step is Extract<
-  WorkerInlineWaterfallSpec['steps'][number],
-  { kind: 'code' }
-> {
-  return step.kind === 'code';
-}
-
-function extractWorkerInlineCodeStepValue(
-  output: string,
-  result: unknown,
-): unknown {
-  if (
-    result &&
-    typeof result === 'object' &&
-    !Array.isArray(result) &&
-    output in result
-  ) {
-    return (result as Record<string, unknown>)[output] ?? null;
-  }
-  return result ?? null;
-}
-
 function isCompletedWorkerFieldValue(value: unknown): boolean {
   return (
     value !== null &&
@@ -2042,9 +2590,6 @@ type WorkerConditionalStepResolver = {
 
 type WorkerStepProgramStep = {
   name: string;
-  recompute?: boolean;
-  recomputeOnError?: boolean;
-  staleAfterSeconds?: AuthoredStaleAfterSeconds;
   resolver:
     | WorkerStepResolver
     | WorkerConditionalStepResolver
@@ -2078,22 +2623,10 @@ type WorkerMapOptions = {
   onRowError?: 'isolate' | 'fail';
 };
 
-function workerCellPoliciesFromSteps(
-  steps: readonly WorkerStepProgramStep[],
-): CellStalenessPolicyByField {
-  return cellPoliciesFromDatasetSteps(steps);
-}
-
-function authoredWorkerCellPoliciesFromSteps(
-  steps: readonly WorkerStepProgramStep[],
-): AuthoredCellStalenessPolicyByField {
-  return authoredCellPoliciesFromDatasetSteps(steps);
-}
-
 /**
  * Per-cell terminal state recorded by map row execution and merged into the
  * Runtime Sheet row's `_cell_meta`. 'failed' carries the cell's error message;
- * `shouldRecomputeCell` treats it as recompute on the next run.
+ * call receipts, not cell meta, decide whether provider work is reused.
  */
 type WorkerCellMetaPatchEntry = {
   status: 'cached' | 'skipped' | 'completed' | 'failed';
@@ -2198,6 +2731,10 @@ async function executeWorkerStepProgram(
   let currentRow: Record<string, unknown> = cloneCsvAliasedRow(inputRow);
   for (const step of program.steps) {
     const stepPath = [...(recorder?.path ?? []), step.name];
+    const stepId = stepPath.join('.');
+    const stepOutputColumn = recorder
+      ? stepProgramColumnName(recorder.parentField, stepId)
+      : null;
     const runStep = async (): Promise<WorkerStepResolution> => {
       const resolution = await executeWorkerStepResolver(
         step.resolver,
@@ -2217,18 +2754,19 @@ async function executeWorkerStepProgram(
         ...(resolution.status ? { status: resolution.status } : {}),
       };
     };
-    const resolution = workflowStep
-      ? await (
-          workflowStep.do as unknown as (
-            name: string,
-            callback: () => Promise<WorkerStepResolution>,
-          ) => Promise<WorkerStepResolution>
-        )(stepPath.join('.'), runStep)
-      : await runStep();
+    const executeStep = async (): Promise<WorkerStepResolution> =>
+      workflowStep
+        ? await (
+            workflowStep.do as unknown as (
+              name: string,
+              callback: () => Promise<WorkerStepResolution>,
+            ) => Promise<WorkerStepResolution>
+          )(stepId, runStep)
+        : await runStep();
+    const resolution = await executeStep();
     const value = deserializeDurableStepValue(resolution.value);
     currentRow = cloneCsvAliasedRow(currentRow, { [step.name]: value });
     if (recorder) {
-      const stepId = stepPath.join('.');
       recorder.outputs.push({
         field: `${recorder.parentField}.${stepId}`,
         columnName: stepProgramColumnName(recorder.parentField, stepId),
@@ -2254,187 +2792,6 @@ function sqlishIdentifierPart(value: string): string {
   );
 }
 
-async function executeWorkerWaterfall(
-  req: RunRequest,
-  recorder: RecordedWaterfallOutput[],
-  toolNameOrSpec: string | WorkerInlineWaterfallSpec,
-  input: Record<string, unknown>,
-  opts?: WorkerWaterfallOptions,
-  callbacks?: WorkerCtxCallbacks,
-  workflowStep?: WorkflowStep,
-  resolveToolContract?: WorkerPacingResolver,
-): Promise<unknown | null> {
-  const retrySafeTransientHttp = async (toolId: string): Promise<boolean> =>
-    (await resolveToolContract?.(toolId).catch(() => null))
-      ?.retrySafeTransientHttp === true;
-  // Inline-spec form
-  if (typeof toolNameOrSpec === 'object' && toolNameOrSpec) {
-    const spec = toolNameOrSpec;
-    const collected: Array<{ stepId: string; value: unknown }> = [];
-    for (const step of spec.steps) {
-      let result: unknown;
-      try {
-        if (isWorkerInlineCodeStep(step)) {
-          result = await step.run(input, {
-            tools: {
-              execute: async (request: unknown) => {
-                const args = normalizeToolExecuteArgs(request);
-                return await executeToolWithLifecycle(
-                  req,
-                  args,
-                  workflowStep,
-                  callbacks,
-                  undefined,
-                  undefined,
-                  await retrySafeTransientHttp(args.toolId),
-                );
-              },
-            },
-          });
-        } else {
-          result = await executeToolWithLifecycle(
-            req,
-            {
-              id: step.id,
-              toolId: step.toolId,
-              input: step.mapInput(input),
-            },
-            workflowStep,
-            callbacks,
-            undefined,
-            undefined,
-            await retrySafeTransientHttp(step.toolId),
-          );
-        }
-      } catch {
-        continue;
-      }
-      if (isWorkerInlineCodeStep(step)) {
-        const direct = extractWorkerInlineCodeStepValue(spec.output, result);
-        if (direct != null && direct !== '' && resultHasContent(direct)) {
-          if (Array.isArray(direct)) {
-            for (const entry of direct)
-              collected.push({ stepId: step.id, value: entry });
-          } else {
-            collected.push({ stepId: step.id, value: direct });
-          }
-          if (collected.length >= spec.minResults) {
-            for (const hit of collected.slice(0, spec.minResults)) {
-              recorder.push({
-                waterfallId: spec.id,
-                stepId: hit.stepId,
-                value: hit.value,
-              });
-            }
-            const values = collected
-              .slice(0, spec.minResults)
-              .map((hit) => hit.value);
-            return spec.minResults === 1 ? (values[0] ?? null) : values;
-          }
-        }
-        continue;
-      }
-      // Short-circuit when the step produced a hit. We accept both:
-      // - top-level `output` field (most tools)
-      // - full non-empty result (fallback for older hand-authored specs)
-      if (isRecordLike(result)) {
-        const direct = result[spec.output];
-        if (direct != null && direct !== '' && resultHasContent(direct)) {
-          if (Array.isArray(direct)) {
-            for (const entry of direct)
-              collected.push({ stepId: step.id, value: entry });
-          } else {
-            collected.push({ stepId: step.id, value: direct });
-          }
-          if (collected.length >= spec.minResults) {
-            for (const hit of collected.slice(0, spec.minResults)) {
-              recorder.push({
-                waterfallId: spec.id,
-                stepId: hit.stepId,
-                value: hit.value,
-              });
-            }
-            const values = collected
-              .slice(0, spec.minResults)
-              .map((hit) => hit.value);
-            return spec.minResults === 1 ? (values[0] ?? null) : values;
-          }
-          continue;
-        }
-        if (spec.output in result) {
-          continue;
-        }
-      }
-      if (resultHasContent(result)) {
-        collected.push({ stepId: step.id, value: result });
-        if (collected.length >= spec.minResults) {
-          for (const hit of collected.slice(0, spec.minResults)) {
-            recorder.push({
-              waterfallId: spec.id,
-              stepId: hit.stepId,
-              value: hit.value,
-            });
-          }
-          const values = collected
-            .slice(0, spec.minResults)
-            .map((hit) => hit.value);
-          return spec.minResults === 1 ? (values[0] ?? null) : values;
-        }
-      }
-    }
-    return null;
-  }
-
-  // Provider-list form
-  const toolName = String(toolNameOrSpec);
-  const providers = opts?.providers ?? [];
-  if (providers.length === 0) {
-    try {
-      return await executeToolWithLifecycle(
-        req,
-        { id: toolName, toolId: toolName, input },
-        workflowStep,
-        callbacks,
-        undefined,
-        undefined,
-        await retrySafeTransientHttp(toolName),
-      );
-    } catch {
-      return null;
-    }
-  }
-  let lastError: Error | null = null;
-  for (const provider of providers) {
-    try {
-      const result = await executeToolWithLifecycle(
-        req,
-        {
-          id: `${toolName}:${provider}`,
-          toolId: toolName,
-          input: { ...input, provider },
-        },
-        workflowStep,
-        callbacks,
-        undefined,
-        undefined,
-        await retrySafeTransientHttp(toolName),
-      );
-      if (resultHasContent(result)) {
-        recorder.push({
-          waterfallId: toolName,
-          stepId: provider,
-          value: result,
-        });
-        return result;
-      }
-    } catch (err) {
-      lastError = err as Error;
-    }
-  }
-  if (lastError && providers.length === 1) throw lastError;
-  return null;
-}
-
 async function hashJson(value: unknown): Promise<string> {
   const bytes = new TextEncoder().encode(canonicalizeJson(value));
   const digest = await crypto.subtle.digest('SHA-256', bytes);
@@ -3251,7 +3608,6 @@ async function prepareMapRows(input: {
   rows: Record<string, unknown>[];
   inputOffset: number;
   outputFields: string[];
-  cellPolicies?: CellStalenessPolicyByField;
 }): Promise<{
   inserted: number;
   skipped: number;
@@ -3273,7 +3629,6 @@ async function prepareMapRows(input: {
     }),
     rows,
     inputOffset: input.inputOffset,
-    cellPolicies: input.cellPolicies,
   });
   for (const timing of result.timings ?? []) {
     const phase =
@@ -3448,6 +3803,54 @@ type WorkerPacingResolver = (
   (ResolvedPacingPolicy & { retrySafeTransientHttp: boolean }) | null
 >;
 
+type WorkerToolActionCacheVersionResolver = (toolId: string) => Promise<string>;
+
+function createWorkerToolActionCacheVersionResolver(
+  req: RunRequest,
+): WorkerToolActionCacheVersionResolver {
+  const cache = new Map<string, Promise<string>>();
+  return (toolId: string) => {
+    const normalized = String(toolId || '').trim();
+    if (!normalized) {
+      return Promise.reject(
+        new Error('Runtime tool metadata lookup requires a non-empty tool id.'),
+      );
+    }
+    const cached = cache.get(normalized);
+    if (cached) return cached;
+    const promise = (async () => {
+      const res = await fetchRuntimeApi(
+        req.baseUrl,
+        `/api/v2/plays/runtime-tools/${encodeURIComponent(normalized)}`,
+        {
+          method: 'GET',
+          headers: { authorization: `Bearer ${req.executorToken}` },
+        },
+      );
+      if (!res.ok) {
+        throw new Error(
+          `Runtime tool metadata lookup for ${normalized} failed (${res.status}): ${await res.text()}`,
+        );
+      }
+      const body = (await res.json().catch(() => null)) as {
+        actionCacheVersion?: unknown;
+      } | null;
+      const version =
+        typeof body?.actionCacheVersion === 'string'
+          ? body.actionCacheVersion.trim()
+          : '';
+      if (!version) {
+        throw new Error(
+          `Runtime tool metadata for ${normalized} is missing actionCacheVersion.`,
+        );
+      }
+      return version;
+    })();
+    cache.set(normalized, promise);
+    return promise;
+  };
+}
+
 function createWorkerPacingResolver(req: RunRequest): WorkerPacingResolver {
   const cache = new Map<
     string,
@@ -3592,6 +3995,8 @@ function createMinimalWorkerCtx(
 ): unknown {
   const { governor, resolvePacing: resolveToolPacing } =
     createGovernorForRun(req);
+  const resolveToolActionCacheVersion =
+    createWorkerToolActionCacheVersionResolver(req);
   // Play-call depth/count/per-parent budgets, child-play concurrency, and the
   // lineage snapshot are owned by the Governor (createGovernorForRun above).
   // The worker keeps only substrate mechanism here.
@@ -3645,8 +4050,9 @@ function createMinimalWorkerCtx(
   const executeWithRuntimeReceipt = async <T>(
     key: string,
     execute: () => Promise<T> | T,
-    repairRunningReceiptForSameRun = true,
+    repairRunningReceiptForSameRun = false,
     reclaimRunning = false,
+    repairRunningReceiptForSameRunAfterWaitTimeout = false,
   ): Promise<T> => {
     const serialized = await runWorkerRuntimeReceiptBoundary<unknown>({
       orgId: req.orgId,
@@ -3657,6 +4063,7 @@ function createMinimalWorkerCtx(
       execute: async () => serializeDurableStepValue(await execute()),
       repairRunningReceiptForSameRun,
       reclaimRunning,
+      repairRunningReceiptForSameRunAfterWaitTimeout,
     });
     return deserializeDurableStepValue(serialized) as T;
   };
@@ -3681,31 +4088,31 @@ function createMinimalWorkerCtx(
       false,
     );
   };
-  const nextCtxStepReceiptKey = (name: string): string => {
+  const nextCtxStepReceiptKey = (
+    name: string,
+    staleAfterSeconds?: number | null,
+  ): string => {
     const count = stepCallCounts[name] ?? 0;
     stepCallCounts[name] = count + 1;
-    return count === 0 ? `step:${name}` : `step:${name}:${count}`;
-  };
-  const staleRuntimeSuffix = (staleAfterSeconds?: number): string => {
-    if (staleAfterSeconds === undefined) return '';
-    if (
-      !Number.isFinite(staleAfterSeconds) ||
-      !Number.isInteger(staleAfterSeconds) ||
-      staleAfterSeconds <= 0
-    ) {
-      throw new Error(
-        'staleAfterSeconds must be a positive whole number of seconds.',
-      );
-    }
-    return `:stale:${staleAfterSeconds}:${Math.floor(nowMs() / (staleAfterSeconds * 1000))}`;
+    return buildDurableCtxCallCacheKey({
+      orgId: req.orgId,
+      playId: req.playName,
+      kind: 'step',
+      id: name,
+      semanticKey: count === 0 ? null : String(count),
+      staleAfterSeconds,
+    });
   };
   const rootToolBatchScheduler = new WorkerToolBatchScheduler(
     req,
     governor,
     resolveToolPacing,
+    resolveToolActionCacheVersion,
     abortSignal,
     undefined,
     callbacks,
+    receiptStore,
+    true,
   );
   // Local ancestry chain that always ENDS with the currently-executing play
   // (req.playName). The /api/v2/plays/run lineage validator requires the
@@ -3737,8 +4144,6 @@ function createMinimalWorkerCtx(
           index: number,
         ) => Promise<unknown> | unknown)
     >,
-    cellPolicies?: CellStalenessPolicyByField,
-    authoredCellPolicies?: AuthoredCellStalenessPolicyByField,
     opts?: WorkerMapOptions,
   ): Promise<unknown> => {
     const mapStartedAt = nowMs();
@@ -3925,6 +4330,11 @@ function createMinimalWorkerCtx(
 
     let totalRowsWritten = 0;
 
+    const volatileWorkflowChunkRows = new Map<
+      number,
+      Array<T & Record<string, unknown>>
+    >();
+
     const processChunk = async (
       chunkRows: T[],
       chunkStart: number,
@@ -3949,7 +4359,6 @@ function createMinimalWorkerCtx(
         req,
         tableNamespace: name,
         outputFields,
-        cellPolicies,
         rows: chunkEntries.map(({ row, rowKey }) => ({
           ...row,
           ...mapRowOutcomeRuntimeFields({ key: rowKey }),
@@ -4134,8 +4543,12 @@ function createMinimalWorkerCtx(
         req,
         governor,
         resolveToolPacing,
+        resolveToolActionCacheVersion,
         abortSignal,
         reportSettledToolRequests,
+        callbacks,
+        receiptStore,
+        false,
       );
       const generatedOutputFields = new Set<string>();
       const persistedExecutedIndexes = new Set<number>();
@@ -4296,8 +4709,8 @@ function createMinimalWorkerCtx(
                 const fieldOutputs: Record<string, unknown> = {};
                 const cellMetaPatch: Record<string, WorkerCellMetaPatchEntry> =
                   {};
-                const waterfallOutputs: RecordedWaterfallOutput[] = [];
                 const stepProgramOutputs: RecordedStepProgramOutput[] = [];
+                let activeField: string | null = null;
                 const rowCtx = {
                   ...(ctx as Record<string, unknown>),
                   tools: {
@@ -4311,26 +4724,14 @@ function createMinimalWorkerCtx(
                         request.toolId,
                         request.input,
                         workflowStep,
+                        {
+                          force: request.force === true,
+                          staleAfterSeconds: request.staleAfterSeconds,
+                        },
                       );
                     },
                   },
-                  waterfall: (
-                    toolNameOrSpec: string | WorkerInlineWaterfallSpec,
-                    waterfallInput: Record<string, unknown>,
-                    waterfallOpts?: WorkerWaterfallOptions,
-                  ) =>
-                    executeWorkerWaterfall(
-                      req,
-                      waterfallOutputs,
-                      toolNameOrSpec,
-                      waterfallInput,
-                      waterfallOpts,
-                      callbacks,
-                      workflowStep,
-                      resolveToolPacing,
-                    ),
                 };
-                let activeField: string | null = null;
                 try {
                   for (const [key, value] of fieldEntries) {
                     activeField = key;
@@ -4344,19 +4745,6 @@ function createMinimalWorkerCtx(
                             >
                           )[key]
                         : null;
-                    const reuseDecision = shouldRecomputeCell({
-                      hasValue: isCompletedWorkerFieldValue(enriched[key]),
-                      meta:
-                        rawCellMeta && typeof rawCellMeta === 'object'
-                          ? (rawCellMeta as {
-                              status?: string;
-                              completedAt?: number;
-                              staleAt?: number | null;
-                              staleAfterSeconds?: number | null;
-                            })
-                          : null,
-                      policy: cellPolicies?.[key],
-                    });
                     const previousCell = previousCellFromValue({
                       hasValue: isCompletedWorkerFieldValue(enriched[key]),
                       value: enriched[key],
@@ -4370,15 +4758,6 @@ function createMinimalWorkerCtx(
                             })
                           : null,
                     });
-                    if (reuseDecision.action === 'reuse') {
-                      cellMetaPatch[key] = {
-                        status: 'cached',
-                        stage: key,
-                        reused: true,
-                        runId: req.runId,
-                      };
-                      continue;
-                    }
                     const resolved = await executeWorkerStepResolver(
                       value,
                       enriched,
@@ -4402,18 +4781,11 @@ function createMinimalWorkerCtx(
                         runId: req.runId,
                       };
                     } else {
-                      const completedAt = nowMs();
-                      const stalenessMeta = resolveCompletedCellStalenessMeta({
-                        policy: authoredCellPolicies?.[key],
-                        value: resolved.value,
-                        completedAt,
-                      });
                       cellMetaPatch[key] = {
                         status: 'completed',
                         stage: key,
                         runId: req.runId,
-                        completedAt,
-                        ...stalenessMeta,
+                        completedAt: nowMs(),
                       };
                     }
                     activeField = null;
@@ -4430,13 +4802,6 @@ function createMinimalWorkerCtx(
                       };
                     }
                   }
-                  for (const waterfallOutput of waterfallOutputs) {
-                    const columnName =
-                      `${sqlishIdentifierPart(waterfallOutput.waterfallId)}__` +
-                      sqlishIdentifierPart(waterfallOutput.stepId);
-                    enriched[columnName] = waterfallOutput.value;
-                    generatedOutputFields.add(columnName);
-                  }
                   executedCellMetaPatches[myIndex] =
                     Object.keys(cellMetaPatch).length > 0
                       ? cellMetaPatch
@@ -4645,6 +5010,17 @@ function createMinimalWorkerCtx(
       const publicOut = out.map((row) => publicCsvOutputRow(row));
       const hashStartedAt = nowMs();
       const hash = await hashJson(publicOut);
+      const includeCachedRowsInChunkResult = !workflowStep;
+      if (
+        workflowStep &&
+        canCacheRows &&
+        out.length <= WORKER_DATASET_IN_MEMORY_ROWS
+      ) {
+        volatileWorkflowChunkRows.set(
+          chunkIndex,
+          serializeDurableStepValue(out),
+        );
+      }
       recordRunnerPerfTrace({
         req,
         phase: 'runner.map_chunk.hash',
@@ -4680,8 +5056,13 @@ function createMinimalWorkerCtx(
         rowFailureSamples,
         outputDatasetId: `map:${name}`,
         hash,
+        // Runtime Sheet owns the full row payloads. Native Workflow step
+        // storage may keep only the bounded preview sample; same-run play code
+        // that needs more rows uses volatileWorkflowChunkRows, which is not
+        // part of the persisted step result.
         preview: toWorkflowSerializableValue(publicOut.slice(0, 5)),
         cachedRows:
+          includeCachedRowsInChunkResult &&
           out.length <= WORKER_DATASET_IN_MEMORY_ROWS
             ? serializeDurableStepValue(out)
             : undefined,
@@ -4724,6 +5105,25 @@ function createMinimalWorkerCtx(
       )) as WorkerMapChunkSummary<T & Record<string, unknown>>;
     };
 
+    const readPersistedRows = async (input: {
+      limit: number;
+      offset: number;
+    }) => {
+      const result = await harnessReadSheetDatasetRows({
+        baseUrl: req.baseUrl,
+        executorToken: req.executorToken,
+        orgId: req.orgId,
+        playName: req.playName,
+        tableNamespace: name,
+        runId: req.runId,
+        limit: input.limit,
+        offset: input.offset,
+        userEmail: req.userEmail,
+        preloadedDbSessions: req.preloadedDbSessions ?? null,
+      });
+      return result.rows as Array<T & Record<string, unknown>>;
+    };
+
     const finalize = (totalRowsWritten: number) => {
       const failureSampleSummary =
         totalRowFailureSamples.length > 0
@@ -4761,23 +5161,15 @@ function createMinimalWorkerCtx(
         playName: req.playName,
         name,
         count: totalRowsWritten,
+        // In native Workflows, chunk summaries intentionally omit full row
+        // payloads, so this preview only contains the bounded chunk samples.
+        // Do not synchronously page rows back here: service-binding reads have
+        // no abort handle and can keep an otherwise completed Workflow request
+        // alive until Cloudflare cancels it as hung. The dataset handle remains
+        // page-backed through readRows/export.
         previewRows,
         cachedRows: canCacheRows ? cachedRows : null,
-        readRows: async ({ limit, offset }) => {
-          const result = await harnessReadSheetDatasetRows({
-            baseUrl: req.baseUrl,
-            executorToken: req.executorToken,
-            orgId: req.orgId,
-            playName: req.playName,
-            tableNamespace: name,
-            runId: req.runId,
-            limit,
-            offset,
-            userEmail: req.userEmail,
-            preloadedDbSessions: req.preloadedDbSessions ?? null,
-          });
-          return result.rows as Array<T & Record<string, unknown>>;
-        },
+        readRows: readPersistedRows,
         trace: (phase, ms, extra) =>
           recordRunnerPerfTrace({ req, phase, ms, extra }),
         nowMs,
@@ -4845,7 +5237,9 @@ function createMinimalWorkerCtx(
         );
       }
       if (canCacheRows) {
-        const nextRows = chunkResult.cachedRows ?? [];
+        const volatileRows = volatileWorkflowChunkRows.get(chunkIndex);
+        volatileWorkflowChunkRows.delete(chunkIndex);
+        const nextRows = chunkResult.cachedRows ?? volatileRows ?? [];
         if (
           nextRows.length === chunkResult.rowsWritten &&
           cachedRows.length + nextRows.length <= WORKER_DATASET_IN_MEMORY_ROWS
@@ -4853,6 +5247,7 @@ function createMinimalWorkerCtx(
           cachedRows.push(...nextRows);
         } else {
           cachedRows.length = 0;
+          volatileWorkflowChunkRows.clear();
           canCacheRows = false;
         }
       }
@@ -4904,7 +5299,7 @@ function createMinimalWorkerCtx(
       // step when no row otherwise succeeded) are summarized and registered as
       // a recovered dataset — the failed run then advertises a WORKING export
       // instead of a dead end (#15/#27). The run still fails (the throw below).
-      finalize(totalRowsWritten);
+      await finalize(totalRowsWritten);
       const firstError = totalRowFailureSamples[0]?.error ?? 'unknown error';
       throw new Error(
         `ctx.dataset("${name}") failed for all ${totalRowsFailed} executed rows. ` +
@@ -4912,7 +5307,7 @@ function createMinimalWorkerCtx(
           `(rows are persisted with per-row errors; fix the cause and re-run to resume)`,
       );
     }
-    const dataset = finalize(totalRowsWritten);
+    const dataset = await finalize(totalRowsWritten);
     recordRunnerPerfTrace({
       req,
       phase: 'runner.map.total',
@@ -4944,18 +5339,7 @@ function createMinimalWorkerCtx(
           const fields = Object.fromEntries(
             program.steps.map((step) => [step.name, step.resolver]),
           );
-          const cellPolicies = workerCellPoliciesFromSteps(program.steps);
-          const authoredCellPolicies = authoredWorkerCellPoliciesFromSteps(
-            program.steps,
-          );
-          return runMap(
-            this.name,
-            this.rows,
-            fields,
-            cellPolicies,
-            authoredCellPolicies,
-            opts,
-          );
+          return runMap(this.name, this.rows, fields, opts);
         },
         {
           emptyColumnName:
@@ -5022,7 +5406,7 @@ function createMinimalWorkerCtx(
         throw new Error('ctx.step(name, callback) requires a name.');
       }
       return await executeWithWorkflowStep(
-        `${nextCtxStepReceiptKey(normalizedName)}${staleRuntimeSuffix(options?.staleAfterSeconds)}`,
+        nextCtxStepReceiptKey(normalizedName, options?.staleAfterSeconds),
         callback,
       );
     },
@@ -5044,8 +5428,8 @@ function createMinimalWorkerCtx(
         });
       }
       // Static pipeline JS blocks already execute inside a Workflow step.
-      // Wrapping each generated waterfall step in another step.do can leave
-      // Workers preview runs parked after the last provider callback.
+      // Wrapping each generated step in another step.do can leave Workers
+      // preview runs parked after the last provider callback.
       return (await executeWorkerStepProgram(
         program,
         input,
@@ -5175,18 +5559,7 @@ function createMinimalWorkerCtx(
         const fields = Object.fromEntries(
           fieldsDef.steps.map((step) => [step.name, step.resolver]),
         );
-        const cellPolicies = workerCellPoliciesFromSteps(fieldsDef.steps);
-        const authoredCellPolicies = authoredWorkerCellPoliciesFromSteps(
-          fieldsDef.steps,
-        );
-        return runMap(
-          name,
-          rows,
-          fields,
-          cellPolicies,
-          authoredCellPolicies,
-          opts,
-        );
+        return runMap(name, rows, fields, opts);
       }
       throw new Error(
         'ctx.dataset(key, rows, fields, options) is not supported. Use ctx.dataset(key, rows).withColumn(...).run(options).',
@@ -5202,55 +5575,18 @@ function createMinimalWorkerCtx(
         assertNotAborted(abortSignal);
         const request = normalizeToolExecuteArgs(requestArg);
         assertNoSecretTaint(request.input, 'ctx.tools.execute input');
-        return await executeWithRuntimeReceipt(
-          `tool:${request.id}:${deriveToolRequestIdentity({
-            toolId: request.toolId,
-            requestInput: request.input,
-          })}${staleRuntimeSuffix(request.staleAfterSeconds)}`,
-          () =>
-            rootToolBatchScheduler.execute(
-              request.id,
-              request.toolId,
-              request.input,
-              workflowStep,
-            ),
+        return await rootToolBatchScheduler.execute(
+          request.id,
+          request.toolId,
+          request.input,
+          workflowStep,
+          {
+            force: request.force === true,
+            staleAfterSeconds: request.staleAfterSeconds,
+          },
         );
       },
     },
-    /**
-     * Two shapes:
-     *
-     *   1. ctx.waterfall(toolName, input, { providers })   — provider-fallback
-     *      tool call. Iterates providers in order; returns first non-empty
-     *      result, null on cumulative miss.
-     *
-     *   2. ctx.waterfall(spec, input)                       — inline waterfall
-     *      with a structured spec ({ id, output, minResults, steps[] }). For
-     *      each step, calls step.toolId with step.mapInput(input); if the
-     *      result carries a non-null value at spec.output (or `step.<id>.<output>`),
-     *      short-circuits. Returns the first hit's full response, or null.
-     *
-     * Min-results gating across rows / extract_js / run_if_js are intentionally
-     * NOT replicated here — the harness gives correctness for the common path
-     * first; richer semantics come when we port the shared_libs batch runtime
-     * onto the dedup DO.
-     */
-    async waterfall(
-      toolNameOrSpec: string | WorkerInlineWaterfallSpec,
-      input: Record<string, unknown>,
-      opts?: WorkerWaterfallOptions,
-    ): Promise<unknown | null> {
-      return executeWorkerWaterfall(
-        req,
-        [],
-        toolNameOrSpec,
-        input,
-        opts,
-        callbacks,
-        workflowStep,
-        resolveToolPacing,
-      );
-    },
     async sleep(ms: number): Promise<void> {
       assertNotAborted(abortSignal);
       const durationMs = Math.max(0, Math.round(Number(ms) || 0));
@@ -5285,152 +5621,210 @@ function createMinimalWorkerCtx(
       if (!resolvedName) {
         throw new Error('ctx.runPlay(...) requires a resolvable play name.');
       }
-      const receiptKey = `runPlay:${normalizedKey}:${await hashJson({
-        childPlayName: resolvedName,
-        input,
-      })}${staleRuntimeSuffix(options?.staleAfterSeconds)}`;
-      return await executeWithRuntimeReceipt(receiptKey, async () => {
-        // The Governor owns the play-call lineage: forkChild does the cycle
-        // guard, depth/per-parent/playCall/descendant budget charges, and
-        // returns the snapshot to thread into the child so budgets accumulate
-        // across isolates. Charged inside the receipt boundary so a replay
-        // (cache hit) never double-charges.
-        const childRunId = `${req.runId}:child:${normalizedKey}`;
-        const childGovernance = governor.forkChild({
+      const receiptKey = buildDurableCtxCallCacheKey({
+        orgId: req.orgId,
+        playId: req.playName,
+        kind: 'runPlay',
+        id: normalizedKey,
+        semanticKey: await hashJson({
           childPlayName: resolvedName,
-          childRunId,
-        });
-        const nextDepth = childGovernance.callDepth;
-        const nextParentCalls =
-          governor.snapshot().parentChildCalls[req.playName] ?? 0;
+          input,
+        }),
+        staleAfterSeconds: options?.staleAfterSeconds,
+      });
+      return await executeWithRuntimeReceipt(
+        receiptKey,
+        async () => {
+          // The Governor owns the play-call lineage: forkChild does the cycle
+          // guard, depth/per-parent/playCall/descendant budget charges, and
+          // returns the snapshot to thread into the child so budgets accumulate
+          // across isolates. Charged inside the receipt boundary so a replay
+          // (cache hit) never double-charges.
+          const childRunId = `${req.runId}:child:${normalizedKey}`;
+          const childGovernance = governor.forkChild({
+            childPlayName: resolvedName,
+            childRunId,
+          });
+          const nextDepth = childGovernance.callDepth;
+          const nextParentCalls =
+            governor.snapshot().parentChildCalls[req.playName] ?? 0;
 
-        emitEvent({
-          type: 'log',
-          level: 'info',
-          message: `Starting child play ${resolvedName} (${normalizedKey})`,
-          ts: nowMs(),
-        });
-        const childManifest = req.childPlayManifests?.[resolvedName];
-        if (!childManifest) {
-          throw new Error(
-            `ctx.runPlay(${normalizedKey}) cannot start ${resolvedName}: missing trusted Cloudflare child manifest from top-level submit.`,
+          emitEvent({
+            type: 'log',
+            level: 'info',
+            message: `Starting child play ${resolvedName} (${normalizedKey})`,
+            ts: nowMs(),
+          });
+          const childManifest = req.childPlayManifests?.[resolvedName];
+          if (!childManifest) {
+            throw new Error(
+              `ctx.runPlay(${normalizedKey}) cannot start ${resolvedName}: missing trusted Cloudflare child manifest from top-level submit.`,
+            );
+          }
+          const childIsDatasetBacked = childPipelineUsesCtxDataset(
+            childManifest.staticPipeline,
           );
-        }
-        const childIsDatasetBacked = childPipelineUsesCtxDataset(
-          childManifest.staticPipeline,
-        );
-        const childNeedsWorkflowScheduler = childPipelineNeedsWorkflowScheduler(
-          childManifest.staticPipeline,
-        );
-        console.info('[play.runtime.span]', {
-          event: 'play.runtime.span',
-          phase: 'child_route',
-          runId: req.runId,
-          parentRunId: req.runId,
-          playName: resolvedName,
-          graphHash: req.graphHash ?? null,
-          depth: nextDepth,
-          fanoutIndex: nextParentCalls - 1,
-          childIsDatasetBacked,
-          childNeedsWorkflowScheduler,
-          hasStaticPipeline: Boolean(childManifest.staticPipeline),
-          childTableNamespace:
-            typeof childManifest.staticPipeline?.tableNamespace === 'string'
-              ? childManifest.staticPipeline.tableNamespace
+          const childNeedsWorkflowScheduler =
+            childPipelineNeedsWorkflowScheduler(childManifest.staticPipeline);
+          console.info('[play.runtime.span]', {
+            event: 'play.runtime.span',
+            phase: 'child_route',
+            runId: req.runId,
+            parentRunId: req.runId,
+            playName: resolvedName,
+            graphHash: req.graphHash ?? null,
+            depth: nextDepth,
+            fanoutIndex: nextParentCalls - 1,
+            childIsDatasetBacked,
+            childNeedsWorkflowScheduler,
+            hasStaticPipeline: Boolean(childManifest.staticPipeline),
+            childTableNamespace:
+              typeof childManifest.staticPipeline?.tableNamespace === 'string'
+                ? childManifest.staticPipeline.tableNamespace
+                : null,
+            childStageCount: Array.isArray(childManifest.staticPipeline?.stages)
+              ? childManifest.staticPipeline.stages.length
+              : null,
+            childSubstepCount: Array.isArray(
+              childManifest.staticPipeline?.substeps,
+            )
+              ? childManifest.staticPipeline.substeps.length
               : null,
-          childStageCount: Array.isArray(childManifest.staticPipeline?.stages)
-            ? childManifest.staticPipeline.stages.length
-            : null,
-          childSubstepCount: Array.isArray(
-            childManifest.staticPipeline?.substeps,
-          )
-            ? childManifest.staticPipeline.substeps.length
-            : null,
-        });
-        let childPlaySlot: { release(): void } | null = null;
-        try {
-          childPlaySlot = await governor.acquireChildPlaySlot({
-            signal: abortSignal,
           });
-          const childSubmitStartedAt = nowMs();
-          let started: {
-            workflowId?: string;
-            runId?: string;
-            status?: string;
-            mode?: string;
-            output?: unknown;
-            result?: unknown;
-            error?: unknown;
-            logs?: string[];
-            timings?: Array<{ phase: string; ms: number }>;
-          };
+          let childPlaySlot: { release(): void } | null = null;
           try {
-            started = await submitChildPlayThroughCoordinator({
-              req,
-              coordinatorBinding: cachedCoordinatorBinding,
-              makeRequestId,
-              coordinatorRequestHeaders,
-              allowInline:
-                options?.timeoutMs == null && !childNeedsWorkflowScheduler,
-              body: {
-                name: resolvedName,
-                input: isRecord(input) ? input : {},
-                orgId: req.orgId,
-                callbackBaseUrl: req.callbackUrl,
-                baseUrl: req.baseUrl,
-                parentExecutorToken: req.executorToken,
-                userEmail: req.userEmail ?? '',
-                profile: 'workers_edge',
-                manifest: childManifest,
-                childPlayManifests: req.childPlayManifests ?? null,
-                internalRunPlay: {
-                  rootRunId,
-                  parentRunId: req.runId,
-                  parentPlayName: req.playName,
+            childPlaySlot = await governor.acquireChildPlaySlot({
+              signal: abortSignal,
+            });
+            const childSubmitStartedAt = nowMs();
+            let started: {
+              workflowId?: string;
+              runId?: string;
+              status?: string;
+              mode?: string;
+              output?: unknown;
+              result?: unknown;
+              error?: unknown;
+              logs?: string[];
+              timings?: Array<{ phase: string; ms: number }>;
+            };
+            try {
+              started = await submitChildPlayThroughCoordinator({
+                req,
+                coordinatorBinding: cachedCoordinatorBinding,
+                makeRequestId,
+                coordinatorRequestHeaders,
+                allowInline:
+                  options?.timeoutMs == null && !childNeedsWorkflowScheduler,
+                body: {
+                  name: resolvedName,
+                  input: isRecord(input) ? input : {},
+                  orgId: req.orgId,
+                  callbackBaseUrl: req.callbackUrl,
+                  baseUrl: req.baseUrl,
+                  parentExecutorToken: req.executorToken,
+                  userEmail: req.userEmail ?? '',
+                  profile: 'workers_edge',
+                  manifest: childManifest,
+                  childPlayManifests: req.childPlayManifests ?? null,
+                  internalRunPlay: {
+                    rootRunId,
+                    parentRunId: req.runId,
+                    parentPlayName: req.playName,
+                    key: normalizedKey,
+                    // Per the lineage validator: ancestry tail must equal the
+                    // executor token's play name (the parent making this call).
+                    ancestryPlayIds,
+                    callDepth: nextDepth,
+                    // Cumulative lineage-global budget counters (incl. this
+                    // launch's play/descendant charges) so the child seeds its
+                    // budgets from the lineage total instead of resetting to 0 in
+                    // its isolate. Threading descendantCount in particular keeps
+                    // fan-out descendant accounting lineage-global, matching cjs.
+                    playCallCount: childGovernance.playCallCount,
+                    toolCallCount: childGovernance.toolCallCount,
+                    retryCount: childGovernance.retryCount,
+                    descendantCount: childGovernance.descendantCount,
+                    waterfallStepExecutions:
+                      childGovernance.waterfallStepExecutions,
+                    description:
+                      typeof options?.description === 'string'
+                        ? options.description
+                        : null,
+                  },
+                },
+              });
+            } catch (error) {
+              console.info('[play.runtime.span]', {
+                event: 'play.runtime.span',
+                phase: 'child_submit',
+                runId: req.runId,
+                parentRunId: req.runId,
+                playName: resolvedName,
+                graphHash: req.graphHash ?? null,
+                depth: nextDepth,
+                fanoutIndex: nextParentCalls - 1,
+                ms: nowMs() - childSubmitStartedAt,
+                status: 'failed',
+                errorCode: 'CHILD_SUBMIT_FAILED',
+              });
+              recordRunnerPerfTrace({
+                req,
+                phase: 'ctx_run_play.child_submit',
+                ms: nowMs() - childSubmitStartedAt,
+                extra: {
+                  status: 'failed',
+                  errorCode: 'CHILD_SUBMIT_FAILED',
+                  playName: resolvedName,
                   key: normalizedKey,
-                  // Per the lineage validator: ancestry tail must equal the
-                  // executor token's play name (the parent making this call).
-                  ancestryPlayIds,
-                  callDepth: nextDepth,
-                  // Cumulative lineage-global budget counters (incl. this
-                  // launch's play/descendant charges) so the child seeds its
-                  // budgets from the lineage total instead of resetting to 0 in
-                  // its isolate. Threading descendantCount in particular keeps
-                  // fan-out descendant accounting lineage-global, matching cjs.
-                  playCallCount: childGovernance.playCallCount,
-                  toolCallCount: childGovernance.toolCallCount,
-                  retryCount: childGovernance.retryCount,
-                  descendantCount: childGovernance.descendantCount,
-                  waterfallStepExecutions:
-                    childGovernance.waterfallStepExecutions,
-                  description:
-                    typeof options?.description === 'string'
-                      ? options.description
-                      : null,
+                  depth: nextDepth,
+                  fanoutIndex: nextParentCalls - 1,
+                  childIsDatasetBacked,
+                  childNeedsWorkflowScheduler,
                 },
-              },
-            });
-          } catch (error) {
+              });
+              throw error;
+            }
+            const workflowId = started.workflowId ?? started.runId;
+            if (!workflowId) {
+              const startedError = isRecord(started.error)
+                ? started.error
+                : { message: started.error };
+              const startedErrorMessage =
+                typeof startedError.message === 'string' &&
+                startedError.message.trim()
+                  ? startedError.message.trim()
+                  : null;
+              throw new Error(
+                startedErrorMessage ??
+                  `ctx.runPlay(${normalizedKey}) did not receive a child workflow id.`,
+              );
+            }
             console.info('[play.runtime.span]', {
               event: 'play.runtime.span',
               phase: 'child_submit',
               runId: req.runId,
               parentRunId: req.runId,
+              childRunId: workflowId,
               playName: resolvedName,
               graphHash: req.graphHash ?? null,
               depth: nextDepth,
               fanoutIndex: nextParentCalls - 1,
               ms: nowMs() - childSubmitStartedAt,
-              status: 'failed',
-              errorCode: 'CHILD_SUBMIT_FAILED',
+              status: 'ok',
             });
             recordRunnerPerfTrace({
               req,
               phase: 'ctx_run_play.child_submit',
               ms: nowMs() - childSubmitStartedAt,
               extra: {
-                status: 'failed',
-                errorCode: 'CHILD_SUBMIT_FAILED',
+                status: 'ok',
+                childRunId: workflowId,
+                startedStatus: started.status ?? null,
+                mode: started.mode ?? null,
+                coordinatorTimings: Array.isArray(started.timings)
+                  ? started.timings
+                  : null,
                 playName: resolvedName,
                 key: normalizedKey,
                 depth: nextDepth,
@@ -5439,118 +5833,100 @@ function createMinimalWorkerCtx(
                 childNeedsWorkflowScheduler,
               },
             });
-            throw error;
-          }
-          const workflowId = started.workflowId ?? started.runId;
-          if (!workflowId) {
-            const startedError = isRecord(started.error)
-              ? started.error
-              : { message: started.error };
-            const startedErrorMessage =
-              typeof startedError.message === 'string' &&
-              startedError.message.trim()
-                ? startedError.message.trim()
-                : null;
-            throw new Error(
-              startedErrorMessage ??
-                `ctx.runPlay(${normalizedKey}) did not receive a child workflow id.`,
-            );
-          }
-          console.info('[play.runtime.span]', {
-            event: 'play.runtime.span',
-            phase: 'child_submit',
-            runId: req.runId,
-            parentRunId: req.runId,
-            childRunId: workflowId,
-            playName: resolvedName,
-            graphHash: req.graphHash ?? null,
-            depth: nextDepth,
-            fanoutIndex: nextParentCalls - 1,
-            ms: nowMs() - childSubmitStartedAt,
-            status: 'ok',
-          });
-          recordRunnerPerfTrace({
-            req,
-            phase: 'ctx_run_play.child_submit',
-            ms: nowMs() - childSubmitStartedAt,
-            extra: {
-              status: 'ok',
-              childRunId: workflowId,
-              startedStatus: started.status ?? null,
-              mode: started.mode ?? null,
-              coordinatorTimings: Array.isArray(started.timings)
-                ? started.timings
-                : null,
-              playName: resolvedName,
-              key: normalizedKey,
-              depth: nextDepth,
-              fanoutIndex: nextParentCalls - 1,
-              childIsDatasetBacked,
-              childNeedsWorkflowScheduler,
-            },
-          });
-          const startedStatus = String(started.status ?? '').toLowerCase();
-          if (startedStatus === 'completed') {
-            emitEvent({
-              type: 'log',
-              level: 'info',
-              message: `Completed child play ${resolvedName} (${normalizedKey})`,
-              ts: nowMs(),
-            });
-            return hydrateChildPlayOutputDatasets({
-              req,
-              childRunId: workflowId,
-              childPlayName: resolvedName,
-              value: started.output ?? extractChildPlayOutput(started),
-            });
-          }
-          if (startedStatus === 'failed') {
-            const startedError = isRecord(started.error)
-              ? started.error
-              : { message: started.error };
-            const startedErrorMessage =
-              typeof startedError.message === 'string' &&
-              startedError.message.trim()
-                ? startedError.message.trim()
-                : `Child play ${resolvedName} (${workflowId}) failed.`;
-            throw new Error(startedErrorMessage);
-          }
-          const childWaitStartedAt = nowMs();
-          let waitResult: ChildPlayTerminalWaitResult;
-          try {
-            waitResult = await awaitChildTerminal({
-              parentRunId: req.runId,
-              // CF's WorkflowStep.waitForEvent generic signature is wider than
-              // the small structural shape ChildPlayAwait needs; bridge it the
-              // same way the inline implementation did.
-              workflowStep: workflowStep as unknown as
-                | WorkflowStepLike
-                | undefined,
-              workflowId,
-              playName: resolvedName,
-              key: normalizedKey,
-              timeoutMs: Math.max(
-                1_000,
-                Math.min(options?.timeoutMs ?? 5 * 60_000, 30 * 60_000),
-              ),
-              coordinator: cachedCoordinatorBinding?.readChildTerminalState
-                ? {
-                    readChildTerminalState: (
-                      parentRunId,
-                      eventKey,
-                      timeoutMs,
-                    ) =>
-                      cachedCoordinatorBinding!.readChildTerminalState!(
+            const startedStatus = String(started.status ?? '').toLowerCase();
+            if (startedStatus === 'completed') {
+              emitEvent({
+                type: 'log',
+                level: 'info',
+                message: `Completed child play ${resolvedName} (${normalizedKey})`,
+                ts: nowMs(),
+              });
+              return hydrateChildPlayOutputDatasets({
+                req,
+                childRunId: workflowId,
+                childPlayName: resolvedName,
+                value: started.output ?? extractChildPlayOutput(started),
+              });
+            }
+            if (startedStatus === 'failed') {
+              const startedError = isRecord(started.error)
+                ? started.error
+                : { message: started.error };
+              const startedErrorMessage =
+                typeof startedError.message === 'string' &&
+                startedError.message.trim()
+                  ? startedError.message.trim()
+                  : `Child play ${resolvedName} (${workflowId}) failed.`;
+              throw new Error(startedErrorMessage);
+            }
+            const childWaitStartedAt = nowMs();
+            let waitResult: ChildPlayTerminalWaitResult;
+            try {
+              waitResult = await awaitChildTerminal({
+                parentRunId: req.runId,
+                // CF's WorkflowStep.waitForEvent generic signature is wider than
+                // the small structural shape ChildPlayAwait needs; bridge it the
+                // same way the inline implementation did.
+                workflowStep: workflowStep as unknown as
+                  | WorkflowStepLike
+                  | undefined,
+                workflowId,
+                playName: resolvedName,
+                key: normalizedKey,
+                timeoutMs: Math.max(
+                  1_000,
+                  Math.min(options?.timeoutMs ?? 5 * 60_000, 30 * 60_000),
+                ),
+                coordinator: cachedCoordinatorBinding?.readChildTerminalState
+                  ? {
+                      readChildTerminalState: (
                         parentRunId,
                         eventKey,
                         timeoutMs,
-                      ),
-                  }
-                : null,
-              now: nowMs,
-              hashJson,
-            });
-          } catch (error) {
+                      ) =>
+                        cachedCoordinatorBinding!.readChildTerminalState!(
+                          parentRunId,
+                          eventKey,
+                          timeoutMs,
+                        ),
+                    }
+                  : null,
+                now: nowMs,
+                hashJson,
+              });
+            } catch (error) {
+              console.info('[play.runtime.span]', {
+                event: 'play.runtime.span',
+                phase: 'child_wait',
+                runId: req.runId,
+                parentRunId: req.runId,
+                childRunId: workflowId,
+                playName: resolvedName,
+                graphHash: req.graphHash ?? null,
+                depth: nextDepth,
+                fanoutIndex: nextParentCalls - 1,
+                ms: nowMs() - childWaitStartedAt,
+                status: 'failed',
+                errorCode: 'CHILD_WAIT_FAILED',
+              });
+              recordRunnerPerfTrace({
+                req,
+                phase: 'ctx_run_play.child_wait',
+                ms: nowMs() - childWaitStartedAt,
+                extra: {
+                  status: 'failed',
+                  errorCode: 'CHILD_WAIT_FAILED',
+                  childRunId: workflowId,
+                  playName: resolvedName,
+                  key: normalizedKey,
+                  depth: nextDepth,
+                  fanoutIndex: nextParentCalls - 1,
+                  childIsDatasetBacked,
+                  childNeedsWorkflowScheduler,
+                },
+              });
+              throw error;
+            }
             console.info('[play.runtime.span]', {
               event: 'play.runtime.span',
               phase: 'child_wait',
@@ -5562,16 +5938,17 @@ function createMinimalWorkerCtx(
               depth: nextDepth,
               fanoutIndex: nextParentCalls - 1,
               ms: nowMs() - childWaitStartedAt,
-              status: 'failed',
-              errorCode: 'CHILD_WAIT_FAILED',
+              status: 'ok',
+              waitSource: waitResult.source,
+              waitAttempts: waitResult.attempts ?? null,
+              reportedWaitMs: waitResult.waitMs,
             });
             recordRunnerPerfTrace({
               req,
               phase: 'ctx_run_play.child_wait',
               ms: nowMs() - childWaitStartedAt,
               extra: {
-                status: 'failed',
-                errorCode: 'CHILD_WAIT_FAILED',
+                status: 'ok',
                 childRunId: workflowId,
                 playName: resolvedName,
                 key: normalizedKey,
@@ -5579,60 +5956,31 @@ function createMinimalWorkerCtx(
                 fanoutIndex: nextParentCalls - 1,
                 childIsDatasetBacked,
                 childNeedsWorkflowScheduler,
+                waitSource: waitResult.source,
+                waitAttempts: waitResult.attempts ?? null,
+                reportedWaitMs: waitResult.waitMs,
               },
             });
-            throw error;
-          }
-          console.info('[play.runtime.span]', {
-            event: 'play.runtime.span',
-            phase: 'child_wait',
-            runId: req.runId,
-            parentRunId: req.runId,
-            childRunId: workflowId,
-            playName: resolvedName,
-            graphHash: req.graphHash ?? null,
-            depth: nextDepth,
-            fanoutIndex: nextParentCalls - 1,
-            ms: nowMs() - childWaitStartedAt,
-            status: 'ok',
-            waitSource: waitResult.source,
-            waitAttempts: waitResult.attempts ?? null,
-            reportedWaitMs: waitResult.waitMs,
-          });
-          recordRunnerPerfTrace({
-            req,
-            phase: 'ctx_run_play.child_wait',
-            ms: nowMs() - childWaitStartedAt,
-            extra: {
-              status: 'ok',
+            emitEvent({
+              type: 'log',
+              level: 'info',
+              message: `Completed child play ${resolvedName} (${normalizedKey})`,
+              ts: nowMs(),
+            });
+            return hydrateChildPlayOutputDatasets({
+              req,
               childRunId: workflowId,
-              playName: resolvedName,
-              key: normalizedKey,
-              depth: nextDepth,
-              fanoutIndex: nextParentCalls - 1,
-              childIsDatasetBacked,
-              childNeedsWorkflowScheduler,
-              waitSource: waitResult.source,
-              waitAttempts: waitResult.attempts ?? null,
-              reportedWaitMs: waitResult.waitMs,
-            },
-          });
-          emitEvent({
-            type: 'log',
-            level: 'info',
-            message: `Completed child play ${resolvedName} (${normalizedKey})`,
-            ts: nowMs(),
-          });
-          return hydrateChildPlayOutputDatasets({
-            req,
-            childRunId: workflowId,
-            childPlayName: resolvedName,
-            value: waitResult.output,
-          });
-        } finally {
-          childPlaySlot?.release();
-        }
-      });
+              childPlayName: resolvedName,
+              value: waitResult.output,
+            });
+          } finally {
+            childPlaySlot?.release();
+          }
+        },
+        false,
+        false,
+        true,
+      );
     },
     async fetch(
       key: string,
@@ -5676,12 +6024,19 @@ function createMinimalWorkerCtx(
           `ctx.fetch(${method} ${url}) needs an Idempotency-Key header. Durable plays can replay after waits/retries; add an idempotency key or wrap the side effect in a Deepline integration tool.`,
         );
       }
-      const receiptKey = `fetch:${normalizedKey}:${await hashJson({
-        body,
-        method,
-        safeHeaders,
-        url,
-      })}${staleRuntimeSuffix(options?.staleAfterSeconds)}`;
+      const receiptKey = buildDurableCtxCallCacheKey({
+        orgId: req.orgId,
+        playId: req.playName,
+        kind: 'fetch',
+        id: normalizedKey,
+        semanticKey: await hashJson({
+          body,
+          method,
+          safeHeaders,
+          url,
+        }),
+        staleAfterSeconds: options?.staleAfterSeconds,
+      });
       return await executeWithRuntimeReceipt(receiptKey, async () => {
         const secretHeaders = await resolveSecretAuth(init.auth);
         const headers = {