deepline 0.1.152 → 0.1.154

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

@@ -3,11 +3,9 @@
  *
  * Batching model:
  * 1. ctx.dataset("table_key", rows).withColumn("field", resolver).run() starts all row column resolvers concurrently
- * 2. ctx.waterfall() calls inside field resolvers QUEUE requests (don't execute)
- * 3. ctx.tools.execute() calls inside field resolvers also QUEUE
- * 4. After all rows have queued, executeBatchedWaterfalls() runs provider-by-provider
- * 5. Each provider batch = real HTTP call to /api/v2/integrations/{toolId}/execute
- * 6. Results resolve suspended row promises, rows complete
+ * 2. ctx.tools.execute() calls inside field resolvers QUEUE requests
+ * 3. After all rows have queued, executeBatchedToolCalls() runs provider calls
+ * 4. Results resolve suspended row promises, rows complete
  *
  * Temporal integration:
  * - checkpoint: recovered from heartbeatDetails on retry (skip completed batches)
@@ -22,9 +20,6 @@ import type { PlayDataset, PlayDatasetInput } from '@shared_libs/plays/dataset';
 import {
   compileRequestsWithStrategy,
   executeChunkedRequests,
-  executeWaterfallProviders,
-  formatChunkExecutionError,
-  resolveWaterfallToolId,
 } from './batch-runtime';
 import type { PlayQueueHint } from './governor/rate-state-backend';
 import type { MapRowOutcome } from './durability-store';
@@ -54,15 +49,34 @@ import {
   deserializeToolExecuteResult,
   type ParsedToolExecuteResponse,
   type ToolExecuteResult,
+  type ToolResultExecutionMetadata,
   type ToolResultMetadataInput,
 } from './tool-result';
+import {
+  markToolExecuteResultExecutionOutcome,
+  toolExecutionMetadataForOutcome,
+  toolExecutionOutcomeForDurableReceipt,
+  type DurableReceiptRecoverySource,
+  type ToolExecutionOutcome,
+} from './tool-execution-outcome';
 import {
   TOOL_EXECUTE_TRANSPORT_MAX_ATTEMPTS,
   classifyToolExecuteHttpFailure,
   createToolExecuteHttpFailureAttemptTracker,
 } from './tool-execute-retry-policy';
+import {
+  buildDurableCtxCallCacheKey,
+  buildDurableToolCallAuthScopeDigest,
+  buildDurableToolCallCacheKey,
+} from './durable-call-cache';
+import {
+  RuntimeReceiptWaitTimeoutError,
+  executeWithDurableRuntimeReceipt,
+  runtimeReceiptOutput as durableRuntimeReceiptOutput,
+  waitForCompletedRuntimeReceipt,
+  type DurableReceiptExecutionStore,
+} from './durable-receipt-execution';
 import { isRowIsolationExemptError } from './row-isolation';
-import { sqlSafePlayColumnName } from '@shared_libs/plays/static-pipeline';
 import { createRuntimeDatasetId } from './dataset-id';
 import { dedupeExplicitMapKeyRows } from './map-row-identity';
 import {
@@ -77,18 +91,8 @@ import {
 import {
   DEEPLINE_CELL_META_FIELD,
   previousCellFromValue,
-  resolveCompletedCellStalenessMeta,
-  resolveReusableCellMetaForCurrentPolicy,
-  shouldRecomputeCell,
-  type AuthoredCellStalenessPolicyByField,
-  type CellStalenessMeta,
-  type CellStalenessPolicyByField,
   type PreviousCell,
 } from './cell-staleness';
-import {
-  authoredCellPolicyMap,
-  normalizeAuthoredCellPolicyMap,
-} from '../play-data-plane/cell-policy';
 import {
   cloneCsvAliasedRow,
   stripCsvProjectedFields,
@@ -122,9 +126,6 @@ import {
 import type {
   CsvOptions,
   RowState,
-  WaterfallRequest,
-  WaterfallOptions,
-  InlineWaterfallSpec,
   DatasetOptions,
   ToolCallRequest,
   ToolBatchResult,
@@ -202,15 +203,43 @@ function isUnsafeOutboundUrlError(error: unknown): boolean {
   return error instanceof Error && error.name === 'UnsafeOutboundUrlError';
 }
 
+function publicToolResponseEnvelope(value: unknown): {
+  status: string;
+  raw: unknown;
+  meta?: Record<string, unknown>;
+} | null {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    return null;
+  }
+  const record = value as Record<string, unknown>;
+  if (typeof record.status !== 'string') return null;
+  const toolResponse = record.toolResponse;
+  if (
+    !toolResponse ||
+    typeof toolResponse !== 'object' ||
+    Array.isArray(toolResponse) ||
+    !Object.prototype.hasOwnProperty.call(toolResponse, 'raw')
+  ) {
+    return null;
+  }
+  const response = toolResponse as Record<string, unknown>;
+  return {
+    status: record.status,
+    raw: response.raw,
+    ...(response.meta &&
+    typeof response.meta === 'object' &&
+    !Array.isArray(response.meta)
+      ? { meta: response.meta as Record<string, unknown> }
+      : {}),
+  };
+}
+
 const EXECUTE_TOOL_METADATA_HEADER = 'x-deepline-include-tool-metadata';
 const EXECUTE_RESPONSE_CONTRACT_HEADER = 'x-deepline-execute-response-contract';
 const V2_EXECUTE_RESPONSE_CONTRACT = 'v2-tool-response';
 const IN_MEMORY_STEP_RESULT_PREVIEW_LIMIT = 25;
-const WATERFALL_ROW_MATCH_LOG_SAMPLE_LIMIT = 10;
-const WATERFALL_ROW_MATCH_LOG_INTERVAL = 1_000;
 const BATCH_SIZE_LOG_SAMPLE_LIMIT = 10;
 const STEP_PROGRAM_MAP_DEFINITION = Symbol('deepline.stepProgramMapDefinition');
-const CELL_STALENESS_POLICIES = Symbol('deepline.cellStalenessPolicies');
 
 function shouldPersistMapCellField(fieldName: string): boolean {
   return !fieldName.startsWith('_') || fieldName === '_metadata';
@@ -396,25 +425,6 @@ function stableDigest(value: string): string {
 
 type DurableCtxOperation = 'step' | 'tool' | 'fetch' | 'runPlay';
 
-function staleBucketForSeconds(
-  staleAfterSeconds?: number | null,
-  nowMs = Date.now(),
-): string | null {
-  if (staleAfterSeconds === undefined || staleAfterSeconds === null) {
-    return null;
-  }
-  if (
-    !Number.isFinite(staleAfterSeconds) ||
-    !Number.isInteger(staleAfterSeconds) ||
-    staleAfterSeconds <= 0
-  ) {
-    throw new Error(
-      'staleAfterSeconds must be a positive whole number of seconds.',
-    );
-  }
-  return `${staleAfterSeconds}:${Math.floor(nowMs / (staleAfterSeconds * 1000))}`;
-}
-
 function durableCtxKey(input: {
   orgId?: string | null;
   playId: string;
@@ -423,19 +433,19 @@ function durableCtxKey(input: {
   semanticKey?: string | null;
   staleAfterSeconds?: number | null;
 }): string {
-  const orgId = input.orgId?.trim() || 'org';
-  const playId = input.playId.trim() || 'play';
-  const digest = stableDigest(
-    JSON.stringify({
-      orgId,
-      playId,
-      operation: input.operation,
-      id: input.id,
-      semanticKey: input.semanticKey ?? null,
-      staleBucket: staleBucketForSeconds(input.staleAfterSeconds),
-    }),
-  );
-  return `ctx:${orgId}:${playId}:${input.operation}:${input.id}:${digest}`;
+  if (input.operation === 'tool') {
+    throw new Error(
+      'Durable ctx key is only for non-tool call boundaries; tools use buildDurableToolCallCacheKey.',
+    );
+  }
+  return buildDurableCtxCallCacheKey({
+    orgId: input.orgId,
+    playId: input.playId,
+    kind: input.operation,
+    id: input.id,
+    semanticKey: input.semanticKey,
+    staleAfterSeconds: input.staleAfterSeconds,
+  });
 }
 
 function resolvedPlayRevisionFingerprint(play: ResolvedPlayExecution): string {
@@ -642,102 +652,8 @@ function createPacingResolver(
   };
 }
 
-function isInlineWaterfallSpec(value: unknown): value is InlineWaterfallSpec {
-  if (!value || typeof value !== 'object' || Array.isArray(value)) {
-    return false;
-  }
-  const candidate = value as InlineWaterfallSpec;
-  return (
-    typeof candidate.id === 'string' &&
-    typeof candidate.output === 'string' &&
-    typeof candidate.minResults === 'number' &&
-    candidate.minResults >= 1 &&
-    Array.isArray(candidate.steps) &&
-    candidate.steps.length > 0
-  );
-}
-
-function isInlineWaterfallCodeStep(
-  step: InlineWaterfallSpec['steps'][number],
-): step is Extract<InlineWaterfallSpec['steps'][number], { kind: 'code' }> {
-  return step.kind === 'code';
-}
-
-function isInlineWaterfallToolStep(
-  step: InlineWaterfallSpec['steps'][number],
-): step is Extract<InlineWaterfallSpec['steps'][number], { toolId: string }> {
-  return !isInlineWaterfallCodeStep(step);
-}
-
-function extractInlineWaterfallCodeStepValue(
-  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 isMeaningfulValue(value: unknown): boolean {
-  if (value == null) return false;
-  if (typeof value === 'string') return value.trim().length > 0;
-  if (Array.isArray(value)) return value.length > 0;
-  if (typeof value === 'object') return Object.keys(value).length > 0;
-  return true;
-}
-
-function getValueAtPath(value: unknown, path: string): unknown {
-  let current = value;
-  for (const part of path.split('.').filter(Boolean)) {
-    if (!current || typeof current !== 'object') return undefined;
-    current = (current as Record<string, unknown>)[part];
-  }
-  return current;
-}
-
-async function extractWaterfallOutputValue(
-  toolId: string,
-  output: string,
-  result: unknown,
-  getToolTargetGetters?: (
-    toolId: string,
-    output: string,
-  ) => Promise<readonly string[]>,
-): Promise<unknown> {
-  const getters = getToolTargetGetters
-    ? await getToolTargetGetters(toolId, output)
-    : [];
-  for (const getter of getters) {
-    const value = getValueAtPath(result, getter);
-    if (isMeaningfulValue(value)) {
-      return value;
-    }
-  }
-
-  const directOutputValue = getValueAtPath(result, output);
-  if (directOutputValue !== undefined) {
-    return isMeaningfulValue(directOutputValue) ? directOutputValue : null;
-  }
-
-  if (output === 'people' || output === 'companies') {
-    if (Array.isArray(result)) return result;
-    const direct = getValueAtPath(result, output);
-    if (Array.isArray(direct)) return direct;
-  }
-
-  return isMeaningfulValue(result) ? result : null;
-}
-
 export class PlayContextImpl {
   private rowStates = new Map<number, RowState>();
-  private resolvers = new Map<string, (value: unknown) => void>();
-  private waterfallQueue = new Map<string, WaterfallRequest[]>();
   private toolCallQueue: ToolCallRequest[] = [];
   private toolCallResolvers = new Map<
     string,
@@ -767,14 +683,12 @@ export class PlayContextImpl {
     timeoutMs: number;
   }> = [];
   private processedRowCount = 0;
-  private directToolCallIndex = 0;
   private sleepBoundaryIndex = 0;
   private fetchCallIndex = 0;
   private readonly secretRedactor: SecretRedactionContext =
     createSecretRedactionContext();
   private mapInvocationIndex = 0;
   private readonly stepCallIndexByKey = new Map<string, number>();
-  private readonly waterfallMatchLogCounts = new Map<string, number>();
   /**
    * The single source of every concurrency, budget, and pacing decision for this
    * run-attempt. Tool/play/row slots are blocking semaphores; budgets are charged
@@ -1093,6 +1007,7 @@ export class PlayContextImpl {
     key: string,
     runId: string,
     reclaimRunning = false,
+    forceRefresh = false,
   ): Promise<RuntimeStepReceipt | null> {
     if (!this.#options.claimRuntimeStepReceipt) {
       return null;
@@ -1101,6 +1016,7 @@ export class PlayContextImpl {
       key,
       runId,
       ...(reclaimRunning ? { reclaimRunning: true } : {}),
+      ...(forceRefresh ? { forceRefresh: true } : {}),
     });
     if (!claimed || typeof claimed.key !== 'string' || !claimed.key.trim()) {
       return null;
@@ -1163,122 +1079,267 @@ export class PlayContextImpl {
     };
   }
 
+  private normalizeRuntimeStepReceipt(
+    key: string,
+    receipt: RuntimeStepReceipt | null | undefined,
+  ): RuntimeStepReceipt | null {
+    if (!receipt) return null;
+    if (typeof receipt.key === 'string' && receipt.key.trim()) {
+      return {
+        ...receipt,
+        key: receipt.key.trim(),
+        runId: receipt.runId ?? null,
+      };
+    }
+    return {
+      ...receipt,
+      key: key.trim(),
+      runId: receipt.runId ?? null,
+    };
+  }
+
+  private async getRuntimeStepReceipts(
+    keys: string[],
+  ): Promise<Map<string, RuntimeStepReceipt>> {
+    const uniqueKeys = [
+      ...new Set(keys.map((key) => key.trim()).filter(Boolean)),
+    ];
+    if (uniqueKeys.length === 0) return new Map();
+    const receipts = this.#options.getRuntimeStepReceipts
+      ? await this.#options.getRuntimeStepReceipts({ keys: uniqueKeys })
+      : await Promise.all(
+          uniqueKeys.map((key) => this.getRuntimeStepReceipt(key)),
+        );
+    const byKey = new Map<string, RuntimeStepReceipt>();
+    for (let index = 0; index < receipts.length; index += 1) {
+      const normalized = this.normalizeRuntimeStepReceipt(
+        uniqueKeys[index] ?? '',
+        receipts[index],
+      );
+      if (normalized) byKey.set(normalized.key, normalized);
+    }
+    return byKey;
+  }
+
+  private async claimRuntimeStepReceipts(
+    keys: string[],
+    runId: string,
+    reclaimRunning = false,
+    forceRefresh = false,
+  ): Promise<Map<string, RuntimeStepReceipt>> {
+    const uniqueKeys = [
+      ...new Set(keys.map((key) => key.trim()).filter(Boolean)),
+    ];
+    if (uniqueKeys.length === 0) return new Map();
+    const receipts = this.#options.claimRuntimeStepReceipts
+      ? await this.#options.claimRuntimeStepReceipts({
+          keys: uniqueKeys,
+          runId,
+          ...(reclaimRunning ? { reclaimRunning: true } : {}),
+          ...(forceRefresh ? { forceRefresh: true } : {}),
+        })
+      : await Promise.all(
+          uniqueKeys.map((key) =>
+            this.claimRuntimeStepReceipt(
+              key,
+              runId,
+              reclaimRunning,
+              forceRefresh,
+            ),
+          ),
+        );
+    const byKey = new Map<string, RuntimeStepReceipt>();
+    for (let index = 0; index < receipts.length; index += 1) {
+      const normalized = this.normalizeRuntimeStepReceipt(
+        uniqueKeys[index] ?? '',
+        receipts[index],
+      );
+      if (normalized) byKey.set(normalized.key, normalized);
+    }
+    return byKey;
+  }
+
+  private async completeRuntimeStepReceipts(
+    receipts: Array<{ key: string; runId: string; output: unknown | null }>,
+  ): Promise<Map<string, RuntimeStepReceipt>> {
+    const normalizedInputs = receipts.filter((receipt) => receipt.key.trim());
+    if (normalizedInputs.length === 0) return new Map();
+    for (const receipt of normalizedInputs) {
+      assertNoSecretTaint(receipt.output, 'ctx.tool receipt output');
+    }
+    const completed = this.#options.completeRuntimeStepReceipts
+      ? await this.#options.completeRuntimeStepReceipts({
+          receipts: normalizedInputs,
+        })
+      : await Promise.all(
+          normalizedInputs.map((receipt) =>
+            this.completeRuntimeStepReceipt(
+              receipt.key,
+              receipt.runId,
+              receipt.output,
+            ),
+          ),
+        );
+    const byKey = new Map<string, RuntimeStepReceipt>();
+    for (let index = 0; index < completed.length; index += 1) {
+      const normalized = this.normalizeRuntimeStepReceipt(
+        normalizedInputs[index]?.key ?? '',
+        completed[index],
+      );
+      if (normalized) byKey.set(normalized.key, normalized);
+    }
+    return byKey;
+  }
+
+  private async failRuntimeStepReceipts(
+    receipts: Array<{ key: string; runId: string; error: string }>,
+  ): Promise<Map<string, RuntimeStepReceipt>> {
+    const normalizedInputs = receipts.filter((receipt) => receipt.key.trim());
+    if (normalizedInputs.length === 0) return new Map();
+    const failed = this.#options.failRuntimeStepReceipts
+      ? await this.#options.failRuntimeStepReceipts({
+          receipts: normalizedInputs,
+        })
+      : await Promise.all(
+          normalizedInputs.map((receipt) =>
+            this.failRuntimeStepReceipt(
+              receipt.key,
+              receipt.runId,
+              receipt.error,
+            ),
+          ),
+        );
+    const byKey = new Map<string, RuntimeStepReceipt>();
+    for (let index = 0; index < failed.length; index += 1) {
+      const normalized = this.normalizeRuntimeStepReceipt(
+        normalizedInputs[index]?.key ?? '',
+        failed[index],
+      );
+      if (normalized) byKey.set(normalized.key, normalized);
+    }
+    return byKey;
+  }
+
+  private async seedForcedRuntimeStepReceipts(keys: string[]): Promise<void> {
+    const receiptKeys = [
+      ...new Set(keys.map((key) => key.trim()).filter(Boolean)),
+    ];
+    if (receiptKeys.length === 0) return;
+    await this.claimRuntimeStepReceipts(
+      receiptKeys,
+      this.currentRunId,
+      true,
+      true,
+    );
+  }
+
+  private async durableToolCallCacheKey(input: {
+    toolId: string;
+    requestInput: Record<string, unknown>;
+    staleAfterSeconds?: number | null;
+  }): Promise<string> {
+    const providerActionVersion =
+      (await this.#options.getToolActionCacheVersion?.(input.toolId))?.trim() ??
+      '';
+    return buildDurableToolCallCacheKey({
+      orgId: this.#options.orgId,
+      playId: this.governance.currentPlayId,
+      toolId: input.toolId,
+      requestInput: input.requestInput,
+      authScopeDigest: buildDurableToolCallAuthScopeDigest({
+        orgId: this.#options.orgId,
+        userEmail: this.#options.userEmail,
+        toolId: input.toolId,
+      }),
+      providerActionVersion,
+      staleAfterSeconds: input.staleAfterSeconds,
+    });
+  }
+
+  private durableReceiptExecutionStore(): DurableReceiptExecutionStore {
+    return {
+      enabled: Boolean(this.#options.claimRuntimeStepReceipt),
+      get: (receiptKey) => this.getRuntimeStepReceipt(receiptKey),
+      getMany: (receiptKeys) => this.getRuntimeStepReceipts(receiptKeys),
+      claim: (receiptKey, runId, reclaimRunning, forceRefresh) =>
+        this.claimRuntimeStepReceipt(
+          receiptKey,
+          runId,
+          reclaimRunning,
+          forceRefresh,
+        ),
+      complete: (receiptKey, runId, output) =>
+        this.completeRuntimeStepReceipt(receiptKey, runId, output),
+      fail: (receiptKey, runId, error) =>
+        this.failRuntimeStepReceipt(receiptKey, runId, error),
+      canPersistFailure: Boolean(this.#options.failRuntimeStepReceipt),
+      canPersistCompletion: Boolean(this.#options.completeRuntimeStepReceipt),
+    };
+  }
+
+  private runtimeReceiptOutput<T>(receipt: RuntimeStepReceipt): T {
+    return durableRuntimeReceiptOutput<T>(receipt);
+  }
+
+  private async waitForCompletedRuntimeToolReceipt(
+    key: string,
+  ): Promise<RuntimeStepReceipt> {
+    return await waitForCompletedRuntimeReceipt({
+      receiptKey: key,
+      store: this.durableReceiptExecutionStore(),
+    });
+  }
+
   private async executeWithRuntimeReceipt<T>(
     operation: DurableCtxOperation,
     id: string,
     runId: string,
     opts: {
       force?: boolean;
+      receiptKey?: string | null;
       semanticKey?: string | null;
       staleAfterSeconds?: number | null;
       repairRunningReceiptForSameRun?: boolean;
+      repairRunningReceiptForSameRunAfterWaitTimeout?: boolean;
       reclaimRunning?: boolean;
       markSkipped?: (output: T) => Promise<void> | void;
+      onRecovered?: (
+        output: T,
+        receipt: RuntimeStepReceipt,
+        source: DurableReceiptRecoverySource,
+      ) => T;
+      onClaimedResult?: (output: T, receiptKey: string) => T;
       execute: () => Promise<T>;
     },
   ): Promise<T> {
-    if (!this.#options.claimRuntimeStepReceipt) {
-      return await opts.execute();
-    }
-    if (opts.force === true) {
-      return await opts.execute();
-    }
-    const receiptKey = durableCtxKey({
-      orgId: this.#options.orgId,
-      playId: this.governance.currentPlayId,
+    const receiptKey =
+      opts.receiptKey?.trim() ||
+      durableCtxKey({
+        orgId: this.#options.orgId,
+        playId: this.governance.currentPlayId,
+        operation,
+        id,
+        semanticKey: opts.semanticKey,
+        staleAfterSeconds: opts.staleAfterSeconds,
+      });
+    return await executeWithDurableRuntimeReceipt<T>({
       operation,
       id,
-      semanticKey: opts.semanticKey,
-      staleAfterSeconds: opts.staleAfterSeconds,
-    });
-    const recoverCompletedReceipt = async (
-      receipt: RuntimeStepReceipt,
-    ): Promise<T> => {
-      this.log(`ctx.${operation}(${id}): recovered result from receipt`);
-      if (receipt.output === undefined) {
-        return receipt.output as T;
-      }
-      // Tool results are persisted in their serialized form (live getters and
-      // the non-enumerable toolOutput/_metadata fields do not survive JSON
-      // storage). Rehydrate so a recovered `ctx.tools.execute` result behaves
-      // exactly like a live one — same contract as dataset cell persistence.
-      const output = isSerializedToolExecuteResult(receipt.output)
-        ? (deserializeToolExecuteResult(receipt.output) as T)
-        : (receipt.output as T);
-      if (opts.markSkipped) {
-        await opts.markSkipped(output);
-      }
-      return output;
-    };
-    const claimed = await this.claimRuntimeStepReceipt(
-      receiptKey,
       runId,
-      opts.reclaimRunning === true,
-    );
-    if (claimed?.status === 'completed' || claimed?.status === 'skipped') {
-      return await recoverCompletedReceipt(claimed);
-    }
-    if (!claimed) {
-      const latest = await this.getRuntimeStepReceipt(receiptKey);
-      if (latest?.status === 'completed' || latest?.status === 'skipped') {
-        return await recoverCompletedReceipt(latest);
-      }
-      if (latest?.status === 'running') {
-        // Running receipts are in-flight telemetry, not locks. Execute in
-        // parallel and let completion reconcile against the latest receipt.
-      } else {
-        if (latest?.status === 'failed') {
-          throw new Error(
-            `ctx.${operation}(${id}): receipt is failed and could not be claimed: ${latest.error ?? 'unknown error'}.`,
-          );
-        }
-        throw new Error(
-          `ctx.${operation}(${id}): receipt claim did not return execution ownership.`,
-        );
-      }
-    } else if (claimed.status === 'running') {
-      // Existing running receipts do not grant exclusive execution ownership.
-      // The completion path decides whether this attempt is still the newest.
-    } else if (claimed.status === 'failed') {
-      throw new Error(
-        `ctx.${operation}(${id}): receipt is failed and could not be claimed: ${claimed.error ?? 'unknown error'}.`,
-      );
-    }
-
-    let result: T;
-    try {
-      result = await opts.execute();
-      assertNoSecretTaint(result, `ctx.${operation} result`);
-    } catch (error) {
-      const failed = await this.failRuntimeStepReceipt(
-        receiptKey,
-        runId,
-        this.formatRuntimeError(error),
-      );
-      if (!failed && this.#options.failRuntimeStepReceipt) {
-        throw new Error(
-          `ctx.${operation}(${id}): execution failed and failed receipt could not be persisted: ${this.formatRuntimeError(error)}`,
-        );
-      }
-      throw error;
-    }
-    // Persist tool results in their serialized form so the recovery path can
-    // rebuild the live ToolExecuteResult wrapper (see recoverCompletedReceipt).
-    const completed = await this.completeRuntimeStepReceipt(
       receiptKey,
-      runId,
-      isToolExecuteResult(result) ? serializeToolExecuteResult(result) : result,
-    );
-    if (!completed && this.#options.completeRuntimeStepReceipt) {
-      return result;
-    }
-    if (
-      completed &&
-      (completed.status === 'completed' || completed.status === 'skipped')
-    ) {
-      return await recoverCompletedReceipt(completed);
-    }
-    return result;
+      store: this.durableReceiptExecutionStore(),
+      force: opts.force,
+      repairRunningReceiptForSameRun: opts.repairRunningReceiptForSameRun,
+      repairRunningReceiptForSameRunAfterWaitTimeout:
+        opts.repairRunningReceiptForSameRunAfterWaitTimeout,
+      reclaimRunning: opts.reclaimRunning,
+      markSkipped: opts.markSkipped,
+      onRecovered: opts.onRecovered,
+      onClaimedResult: opts.onClaimedResult,
+      formatError: (error) => this.formatRuntimeError(error),
+      log: (message) => this.log(message),
+      execute: opts.execute,
+    });
   }
 
   private get currentRunId(): string {
@@ -1402,29 +1463,6 @@ export class PlayContextImpl {
     });
   }
 
-  private emitQueuedInlineWaterfallSteps(
-    rowId: number,
-    key: string | null,
-    tableNamespace: string | null,
-    spec: InlineWaterfallSpec,
-  ): void {
-    for (const step of spec.steps) {
-      this.emitCellUpdate({
-        rowId,
-        key,
-        tableNamespace,
-        columnName: sqlSafePlayColumnName(`${spec.id}.${step.id}`),
-        status: 'queued',
-        stage: step.id,
-        provider: isInlineWaterfallToolStep(step) ? step.toolId : 'code',
-        producer: isInlineWaterfallToolStep(step)
-          ? { kind: 'tool', toolId: step.toolId, displayName: step.toolId }
-          : { kind: 'code', id: step.id, displayName: step.id },
-        value: null,
-      });
-    }
-  }
-
   private isCompletedFieldValue(value: unknown): boolean {
     return (
       value !== null &&
@@ -1433,48 +1471,6 @@ export class PlayContextImpl {
     );
   }
 
-  private existingFieldReuseDecision(
-    row: Record<string, unknown>,
-    fieldName: string,
-    policies?: CellStalenessPolicyByField,
-    authoredPolicies?: AuthoredCellStalenessPolicyByField,
-  ): {
-    reuse: boolean;
-    completedAt?: number;
-    stalenessMeta?: Pick<CellStalenessMeta, 'staleAfterSeconds' | 'staleAt'>;
-  } {
-    const hasValue =
-      Object.prototype.hasOwnProperty.call(row, fieldName) &&
-      this.isCompletedFieldValue(row[fieldName]);
-    const meta = this.cellMetaForField(row, fieldName);
-    const completedAt =
-      typeof meta?.completedAt === 'number' && Number.isFinite(meta.completedAt)
-        ? meta.completedAt
-        : undefined;
-    const stalenessMeta = resolveReusableCellMetaForCurrentPolicy({
-      hasValue,
-      value: row[fieldName],
-      meta,
-      policy: authoredPolicies?.[fieldName],
-    });
-    const decisionMeta =
-      Object.keys(stalenessMeta).length > 0
-        ? { ...meta, ...stalenessMeta }
-        : meta;
-    const reuse =
-      shouldRecomputeCell({
-        hasValue,
-        value: row[fieldName],
-        meta: decisionMeta,
-        policy: policies?.[fieldName],
-      }).action === 'reuse';
-    return {
-      reuse,
-      ...(completedAt !== undefined ? { completedAt } : {}),
-      ...(Object.keys(stalenessMeta).length > 0 ? { stalenessMeta } : {}),
-    };
-  }
-
   // --- Tool-result cells survive the dataset persist/resume boundary ---
   // A ToolExecuteResult carries live getter methods that cannot be serialized
   // to durable storage. We store its serialized form on write and rehydrate it
@@ -1544,24 +1540,6 @@ export class PlayContextImpl {
       : null;
   }
 
-  private cellPoliciesForMapDefinition(
-    definition: MapFieldDefinition<Record<string, unknown>>,
-  ): CellStalenessPolicyByField {
-    const raw = (definition as Record<symbol, unknown>)[
-      CELL_STALENESS_POLICIES
-    ];
-    return normalizeAuthoredCellPolicyMap(raw);
-  }
-
-  private authoredCellPoliciesForMapDefinition(
-    definition: MapFieldDefinition<Record<string, unknown>>,
-  ): AuthoredCellStalenessPolicyByField {
-    const raw = (definition as Record<symbol, unknown>)[
-      CELL_STALENESS_POLICIES
-    ];
-    return authoredCellPolicyMap(raw);
-  }
-
   private toVisibleDataPatch(
     fields: Record<string, unknown>,
   ): Record<string, unknown> {
@@ -1579,31 +1557,14 @@ export class PlayContextImpl {
     return String(error);
   }
 
-  private logWaterfallMatch(input: {
-    queueKey: string;
-    rowId: number;
-    provider: string;
-  }): void {
-    const count = (this.waterfallMatchLogCounts.get(input.queueKey) ?? 0) + 1;
-    this.waterfallMatchLogCounts.set(input.queueKey, count);
-
-    if (count <= WATERFALL_ROW_MATCH_LOG_SAMPLE_LIMIT) {
-      this.log(
-        `    Row ${input.rowId}: found with ${input.provider} (${count}/${WATERFALL_ROW_MATCH_LOG_SAMPLE_LIMIT} sample)`,
-      );
-      if (count === WATERFALL_ROW_MATCH_LOG_SAMPLE_LIMIT) {
-        this.log(
-          `    Further per-row matches for ${input.queueKey} will be summarized every ${WATERFALL_ROW_MATCH_LOG_INTERVAL.toLocaleString()} hits.`,
-        );
-      }
-      return;
-    }
-
-    if (count % WATERFALL_ROW_MATCH_LOG_INTERVAL === 0) {
-      this.log(
-        `    ${count.toLocaleString()} rows matched for ${input.queueKey}; latest row ${input.rowId} with ${input.provider}`,
-      );
-    }
+  private effectiveToolCallCachePolicy(options?: ToolCallOptions): {
+    force: boolean;
+    staleAfterSeconds?: number | null;
+  } {
+    return {
+      force: options?.force === true,
+      staleAfterSeconds: options?.staleAfterSeconds ?? null,
+    };
   }
 
   private summarizeBatchSizes(sizes: readonly number[]): string {
@@ -1675,30 +1636,24 @@ export class PlayContextImpl {
     result: unknown;
     metadata?: ToolResultMetadataInput | null;
     meta?: Record<string, unknown>;
-    cached: boolean;
-    source: 'live' | 'checkpoint' | 'cache';
-    cacheKey?: string;
+    execution: ToolResultExecutionMetadata;
   }): Promise<ToolExecuteResult> {
     if (isToolExecuteResult(input.result)) {
-      return cloneToolExecuteResultWithExecution(input.result, {
-        idempotent: true,
-        cached: input.cached,
-        source: input.source,
-        ...(input.cacheKey ? { cacheKey: input.cacheKey } : {}),
-      });
+      return cloneToolExecuteResultWithExecution(input.result, input.execution);
     }
+    const publicToolResult = publicToolResponseEnvelope(input.result);
     return createToolExecuteResult({
-      status: input.status,
+      status: publicToolResult?.status ?? input.status,
       jobId: input.jobId,
-      result: input.result,
+      result: publicToolResult
+        ? {
+            data: publicToolResult.raw,
+            ...(publicToolResult.meta ? { meta: publicToolResult.meta } : {}),
+          }
+        : input.result,
       metadata:
         input.metadata ?? (await this.resolveToolResultMetadata(input.toolId)),
-      execution: {
-        idempotent: true,
-        cached: input.cached,
-        source: input.source,
-        ...(input.cacheKey ? { cacheKey: input.cacheKey } : {}),
-      },
+      execution: input.execution,
       meta: input.meta,
     });
   }
@@ -1710,13 +1665,9 @@ export class PlayContextImpl {
     metadata?: ToolResultMetadataInput | null,
     jobId?: string,
     meta?: Record<string, unknown>,
-  ): Promise<void> {
-    const cacheKey = this.buildToolResultCacheKey({
-      rowId: request.rowId,
-      tableNamespace: request.tableNamespace,
-      rowKey: request.rowKey ?? undefined,
-      callId: request.callId,
-    });
+  ): Promise<unknown> {
+    const cacheKey = request.cacheKey;
+    const receiptKey = request.receiptKey?.trim() || null;
     const wrapped = await this.wrapToolExecutionResult({
       toolId,
       status: result == null ? 'no_result' : 'completed',
@@ -1724,15 +1675,128 @@ export class PlayContextImpl {
       result,
       metadata,
       meta,
-      cached: false,
-      source: 'live',
-      cacheKey,
+      execution: toolExecutionMetadataForOutcome({
+        kind: 'live',
+        cacheKey,
+        receiptKey,
+      }),
+    });
+    const completed = receiptKey
+      ? (
+          await this.completeRuntimeStepReceipts([
+            {
+              key: receiptKey,
+              runId: this.currentRunId,
+              output: serializeToolExecuteResult(wrapped),
+            },
+          ])
+        ).get(receiptKey)
+      : null;
+    return await this.finalizeResolvedToolCall(
+      toolId,
+      request,
+      wrapped,
+      completed,
+    );
+  }
+
+  private async resolveToolCallBatchResults(
+    toolId: string,
+    entries: Array<{
+      request: ToolCallRequest;
+      result: unknown | null;
+      metadata?: ToolResultMetadataInput | null;
+      jobId?: string;
+      meta?: Record<string, unknown>;
+    }>,
+  ): Promise<unknown[]> {
+    const wrappedEntries = await Promise.all(
+      entries.map(async (entry) => ({
+        ...entry,
+        wrapped: await this.wrapToolExecutionResult({
+          toolId,
+          status: entry.result == null ? 'no_result' : 'completed',
+          jobId: entry.jobId,
+          result: entry.result,
+          metadata: entry.metadata,
+          meta: entry.meta,
+          execution: toolExecutionMetadataForOutcome({
+            kind: 'live',
+            cacheKey: entry.request.cacheKey,
+            receiptKey: entry.request.receiptKey,
+          }),
+        }),
+      })),
+    );
+    const receiptInputs = wrappedEntries.flatMap((entry) => {
+      const receiptKey = entry.request.receiptKey?.trim() || null;
+      return receiptKey
+        ? [
+            {
+              key: receiptKey,
+              runId: this.currentRunId,
+              output: serializeToolExecuteResult(entry.wrapped),
+            },
+          ]
+        : [];
     });
-    this.cacheToolResult(toolId, cacheKey, wrapped);
+    const completedByKey =
+      receiptInputs.length > 0
+        ? await this.completeRuntimeStepReceipts(receiptInputs)
+        : new Map<string, RuntimeStepReceipt>();
+    const results: unknown[] = [];
+    for (const entry of wrappedEntries) {
+      const receiptKey = entry.request.receiptKey?.trim() || null;
+      results.push(
+        await this.finalizeResolvedToolCall(
+          toolId,
+          entry.request,
+          entry.wrapped,
+          receiptKey ? completedByKey.get(receiptKey) : null,
+        ),
+      );
+    }
+    return results;
+  }
+
+  private async finalizeResolvedToolCall(
+    toolId: string,
+    request: ToolCallRequest,
+    wrapped: ToolExecuteResult,
+    completed: RuntimeStepReceipt | null | undefined,
+  ): Promise<unknown> {
+    const cacheKey = request.cacheKey;
+    const finalWrapped =
+      (completed?.status === 'completed' || completed?.status === 'skipped') &&
+      completed.runId !== this.currentRunId
+        ? await this.wrapToolExecutionResult({
+            toolId,
+            status:
+              completed.output === null || completed.output === undefined
+                ? 'no_result'
+                : 'completed',
+            result: this.runtimeReceiptOutput(completed),
+            execution: toolExecutionMetadataForOutcome(
+              completed.runId === this.currentRunId
+                ? {
+                    kind: 'live',
+                    cacheKey,
+                    receiptKey: request.receiptKey,
+                  }
+                : {
+                    kind: 'cache',
+                    cacheKey,
+                    receiptKey: request.receiptKey ?? '',
+                    attachedToReceiptKey: request.receiptKey,
+                  },
+            ),
+          })
+        : wrapped;
+    this.cacheToolResult(toolId, cacheKey, finalWrapped);
 
     const resolver = this.toolCallResolvers.get(request.callId);
     if (resolver) {
-      resolver.resolve(wrapped);
+      resolver.resolve(finalWrapped);
       this.toolCallResolvers.delete(request.callId);
     }
 
@@ -1748,17 +1812,39 @@ export class PlayContextImpl {
       error: null,
       dataPatch: {},
     });
+    return finalWrapped;
   }
 
-  private rejectToolCall(
+  private async rejectToolCall(
     toolId: string,
     request: ToolCallRequest,
     error: unknown,
-  ): void {
+    options?: { persistReceiptFailure?: boolean },
+  ): Promise<void> {
     const message = this.formatRuntimeError(error);
+    let rejectionError = error;
+    const receiptKey = request.receiptKey?.trim() || null;
+    if (receiptKey && options?.persistReceiptFailure !== false) {
+      try {
+        await this.failRuntimeStepReceipts([
+          {
+            key: receiptKey,
+            runId: this.currentRunId,
+            error: message,
+          },
+        ]);
+      } catch (receiptError) {
+        rejectionError = new AggregateError(
+          [error, receiptError],
+          'Tool call failed and durable receipt could not be marked failed',
+        );
+      }
+    }
     const resolver = this.toolCallResolvers.get(request.callId);
     if (resolver) {
-      resolver.reject(error instanceof Error ? error : new Error(message));
+      resolver.reject(
+        rejectionError instanceof Error ? rejectionError : new Error(message),
+      );
       this.toolCallResolvers.delete(request.callId);
     }
 
@@ -1875,22 +1961,6 @@ export class PlayContextImpl {
     options?: DatasetOptions<T>,
   ): Promise<PlayDataset<Record<string, unknown>>> {
     const definition = this.stepProgramToMapDefinition(program);
-    Object.defineProperty(definition, CELL_STALENESS_POLICIES, {
-      value: Object.fromEntries(
-        program.steps.map((step) => [
-          step.name,
-          {
-            ...(step.recompute === true ? { recompute: true } : {}),
-            ...(step.recomputeOnError === true
-              ? { recomputeOnError: true }
-              : {}),
-            ...(step.staleAfterSeconds === undefined
-              ? {}
-              : { staleAfterSeconds: step.staleAfterSeconds }),
-          },
-        ]),
-      ) satisfies AuthoredCellStalenessPolicyByField,
-    });
     return this.runMapDefinition(key, items, definition, options);
   }
 
@@ -1940,7 +2010,6 @@ export class PlayContextImpl {
     let rawItems: Record<string, unknown>[] = [];
     let itemsToProcess: Array<Record<string, unknown>> = [];
     let itemOriginalIndexes: number[] = [];
-    let completedItemsByKey: Map<string, Record<string, unknown>> | null = null;
     const datasetColumnNames = Object.keys(input);
     const stripFieldOutputs = (row: Record<string, unknown>) => {
       const stripped = cloneCsvAliasedRow(row);
@@ -2066,7 +2135,6 @@ export class PlayContextImpl {
           playId: this.#options.playId,
           runId: this.#options.runId,
           staticPipeline: this.#options.staticPipeline,
-          cellPolicies: this.cellPoliciesForMapDefinition(input),
         },
       );
       resolvedTableNamespace = normalizeTableNamespace(
@@ -2109,21 +2177,6 @@ export class PlayContextImpl {
         });
       itemsToProcess = pendingItems.map((item) => item.row);
       itemOriginalIndexes = pendingItems.map((item) => item.index);
-      if (mapStartResult.completedRows.length > 0) {
-        completedItemsByKey = new Map();
-        for (
-          let index = 0;
-          index < mapStartResult.completedRows.length;
-          index += 1
-        ) {
-          const row = mapStartResult.completedRows[index]!;
-          const rowKey = persistedRowIdentity(row, index);
-          if (rowKey) completedItemsByKey.set(rowKey, row);
-        }
-        this.log(
-          `Resuming: ${mapStartResult.completedRows.length} already completed, ${itemsToProcess.length} pending`,
-        );
-      }
     }
 
     const mapScope = this.createMapExecutionScope({
@@ -2131,8 +2184,7 @@ export class PlayContextImpl {
       artifactTableNamespace: resolvedTableNamespace,
       explicitKey: explicitKeyResolver,
     });
-    const completedRowKeys =
-      completedItemsByKey != null ? [...completedItemsByKey.keys()] : [];
+    const completedRowKeys: string[] = [];
     const pendingRowKeys = itemsToProcess.map((item, index) =>
       rowIdentity(this.toOutputRow(item), itemOriginalIndexes[index] ?? index),
     );
@@ -2230,7 +2282,7 @@ export class PlayContextImpl {
         options?.description,
         {
           totalRows: totalInputCount,
-          completedRows: (completedItemsByKey?.size ?? 0) + duplicateReuseCount,
+          completedRows: duplicateReuseCount,
         },
         {
           onRowError: options?.onRowError,
@@ -2274,7 +2326,6 @@ export class PlayContextImpl {
       this.toPublicOutputRow(row.data),
     );
     const results =
-      !completedItemsByKey &&
       mapResult.failedRows.length === 0 &&
       directCompletedResults.length === rawItems.length
         ? directCompletedResults
@@ -2284,15 +2335,11 @@ export class PlayContextImpl {
               return [];
             }
             return [
-              this.toPublicOutputRow(
-                resultsByKey.get(rowKey) ??
-                  completedItemsByKey?.get(rowKey) ??
-                  rawItem,
-              ),
+              this.toPublicOutputRow(resultsByKey.get(rowKey) ?? rawItem),
             ];
           });
     const executedCount = rowsToExecute.length;
-    const reusedCount = Math.max(0, totalInputCount - executedCount);
+    const reusedCount = duplicateReuseCount;
 
     // Persist executed rows to the tenant runtime sheet — the sheet is the
     // source of truth, not this in-memory results array. Chunked by rows AND
@@ -2403,9 +2450,6 @@ export class PlayContextImpl {
     },
   ): Promise<FieldMapRunResult> {
     const fieldEntries = Object.entries(definition);
-    const cellPolicies = this.cellPoliciesForMapDefinition(definition);
-    const authoredCellPolicies =
-      this.authoredCellPoliciesForMapDefinition(definition);
     const datasetColumnNames = fieldEntries.map(([fieldName]) => fieldName);
     const visibleFields = fieldEntries
       .map(([fieldName]) => fieldName)
@@ -2454,7 +2498,7 @@ export class PlayContextImpl {
 
     if (completedRows > 0 || pendingRows !== totalRows) {
       this.log(
-        `Starting map over ${totalRows} items with ${visibleFields.length} fields (key: ${normalizedTableNamespace}; ${completedRows} already satisfied; ${pendingRows} pending)`,
+        `Starting map over ${totalRows} items with ${visibleFields.length} fields (key: ${normalizedTableNamespace}; ${completedRows} duplicate keys skipped; ${pendingRows} pending)`,
       );
     } else {
       this.log(
@@ -2587,8 +2631,6 @@ export class PlayContextImpl {
         visibleFields,
         normalizedTableNamespace,
         executionRowKey,
-        cellPolicies,
-        authoredCellPolicies,
       );
       // One batched frame update for the whole pure map. The per-row loop
       // this replaces ran AFTER every row had already computed, emitting 150k
@@ -2612,7 +2654,7 @@ export class PlayContextImpl {
       this.lastDatasetStep = datasetStep;
       this.activeDatasetStep = null;
       this.log(
-        `Map completed: ${results.length + completedRows} results (${results.length} executed, ${completedRows} already satisfied)`,
+        `Map completed: ${results.length + completedRows} results (${results.length} executed, ${completedRows} duplicate keys skipped)`,
       );
       return {
         completedRows: results.map((row, index) =>
@@ -2674,32 +2716,6 @@ export class PlayContextImpl {
       try {
         for (const [fieldName, resolver] of fieldEntries) {
           activeFieldName = fieldName;
-          const reuseDecision = this.existingFieldReuseDecision(
-            baseRow,
-            fieldName,
-            cellPolicies,
-            authoredCellPolicies,
-          );
-          if (reuseDecision.reuse) {
-            const reusedValue = baseRow[fieldName];
-            computedFields[fieldName] = reusedValue;
-            this.rowStates.get(idx)?.results.set(fieldName, reusedValue);
-            this.emitScopedFieldMetaUpdate({
-              rowId: idx,
-              key: rowKey,
-              tableNamespace: normalizedTableNamespace,
-              fieldName,
-              status: 'cached',
-              reused: true,
-              ...(reuseDecision.completedAt !== undefined
-                ? { completedAt: reuseDecision.completedAt }
-                : {}),
-              ...(reuseDecision.stalenessMeta ?? {}),
-              dataPatch: {},
-            });
-            continue;
-          }
-
           this.emitScopedFieldMetaUpdate({
             rowId: idx,
             key: rowKey,
@@ -2805,12 +2821,6 @@ export class PlayContextImpl {
           const cellValue = this.serializeCellValue(value);
           computedFields[fieldName] = cellValue;
           this.rowStates.get(idx)?.results.set(fieldName, cellValue);
-          const completedAt = Date.now();
-          const stalenessMeta = resolveCompletedCellStalenessMeta({
-            policy: authoredCellPolicies[fieldName],
-            value,
-            completedAt,
-          });
           this.emitScopedFieldMetaUpdate({
             rowId: idx,
             key: rowKey,
@@ -2818,8 +2828,7 @@ export class PlayContextImpl {
             fieldName,
             status: 'completed',
             stage: 'completed',
-            completedAt,
-            ...stalenessMeta,
+            completedAt: Date.now(),
             dataPatch: shouldPersistMapCellField(fieldName)
               ? { [fieldName]: cellValue }
               : {},
@@ -2986,7 +2995,7 @@ export class PlayContextImpl {
       });
     }
     this.log(
-      `Map completed: ${results.length + completedRows} results (${results.length} executed, ${completedRows} already satisfied)`,
+      `Map completed: ${results.length + completedRows} results (${results.length} executed, ${completedRows} duplicate keys skipped)`,
     );
     return {
       completedRows: [...completedRowsToPersist].sort(
@@ -3157,9 +3166,7 @@ export class PlayContextImpl {
 
       const source = Function.prototype.toString.call(resolver);
       return (
-        !source.includes('.tools.execute(') &&
-        !source.includes('.waterfall(') &&
-        !source.includes('.runPlay(')
+        !source.includes('.tools.execute(') && !source.includes('.runPlay(')
       );
     });
   }
@@ -3170,8 +3177,6 @@ export class PlayContextImpl {
     visibleFields: string[],
     tableNamespace: string,
     rowIdentity: (row: Record<string, unknown>, index: number) => string,
-    cellPolicies?: CellStalenessPolicyByField,
-    authoredCellPolicies?: AuthoredCellStalenessPolicyByField,
   ): Promise<Array<Record<string, unknown>>> {
     const results: Array<Record<string, unknown>> = [];
     this.pureMapExecutionActive = true;
@@ -3195,25 +3200,6 @@ export class PlayContextImpl {
         try {
           for (const [fieldName, resolver] of fieldEntries) {
             activeFieldName = fieldName;
-            const reuseDecision = this.existingFieldReuseDecision(
-              baseRow,
-              fieldName,
-              cellPolicies,
-              authoredCellPolicies,
-            );
-            if (reuseDecision.reuse) {
-              computedFields[fieldName] = baseRow[fieldName];
-              rowCellMetaPatch[fieldName] = {
-                status: 'cached',
-                reused: true,
-                ...(reuseDecision.completedAt !== undefined
-                  ? { completedAt: reuseDecision.completedAt }
-                  : {}),
-                ...(reuseDecision.stalenessMeta ?? {}),
-              };
-              continue;
-            }
-
             const value = await this.resolveMapFieldValue(
               resolver,
               item,
@@ -3224,20 +3210,13 @@ export class PlayContextImpl {
               this.previousCellForField(baseRow, fieldName),
             );
             computedFields[fieldName] = this.serializeCellValue(value);
-            const completedAt = Date.now();
-            const stalenessMeta = resolveCompletedCellStalenessMeta({
-              policy: authoredCellPolicies?.[fieldName],
-              value,
-              completedAt,
-            });
             if (shouldPersistMapCellField(fieldName)) {
               rowDataPatch[fieldName] = computedFields[fieldName];
             }
             rowCellMetaPatch[fieldName] = {
               status: 'completed',
               stage: 'completed',
-              completedAt,
-              ...stalenessMeta,
+              completedAt: Date.now(),
             };
           }
 
@@ -3294,14 +3273,13 @@ export class PlayContextImpl {
   private initializeRowStates(items: readonly unknown[]): void {
     for (let idx = 0; idx < items.length; idx += 1) {
       this.rowStates.set(idx, {
-        waterfalls: new Map(),
         results: new Map(),
       });
     }
   }
 
   private async drainQueuedWork<T>(promises: Promise<T>[]): Promise<void> {
-    // Drain loop: each pass resolves queued waterfalls/tool calls.
+    // Drain loop: each pass resolves queued tool calls.
     // When a batch resolves, rows resume and may queue MORE calls
     // (e.g. row does tools.execute('a') then tools.execute('b') sequentially).
     // We keep looping until nothing new is queued and all rows finish.
@@ -3311,7 +3289,7 @@ export class PlayContextImpl {
     // Promise.allSettled(promises) while there is no timer/socket/file handle can
     // let Node exit 0 before main() emits the result envelope. That presents as
     // "Local play runner produced no result" even though the real bug was a
-    // map row waiting for queued tool/waterfall work. Always race row settlement
+    // map row waiting for queued tool work. Always race row settlement
     // against a small timer and re-check the queues instead of blocking forever
     // on promises that may be waiting for this drain loop to do the next batch.
     const raceSettled = () =>
@@ -3322,16 +3300,11 @@ export class PlayContextImpl {
 
     let pass = 0;
     while (true) {
-      const hasPendingWork =
-        this.waterfallQueue.size > 0 || this.toolCallQueue.length > 0;
+      const hasPendingWork = this.toolCallQueue.length > 0;
 
       if (!hasPendingWork) {
         const status = await raceSettled();
-        if (
-          status === 'done' &&
-          this.waterfallQueue.size === 0 &&
-          this.toolCallQueue.length === 0
-        ) {
+        if (status === 'done' && this.toolCallQueue.length === 0) {
           break;
         }
 
@@ -3346,13 +3319,9 @@ export class PlayContextImpl {
       pass++;
       this.log(`  Batch pass ${pass}`);
       this.log(
-        `  Queue depth before drain: waterfalls=${this.waterfallQueue.size} tool_calls=${this.toolCallQueue.length}`,
+        `  Queue depth before drain: tool_calls=${this.toolCallQueue.length}`,
       );
 
-      if (this.waterfallQueue.size > 0) {
-        await this.executeBatchedWaterfalls();
-      }
-
       if (this.toolCallQueue.length > 0) {
         await this.executeBatchedToolCalls();
       }
@@ -3420,99 +3389,6 @@ export class PlayContextImpl {
     );
   }
 
-  async waterfall(
-    toolNameOrSpec: string | InlineWaterfallSpec,
-    input: Record<string, unknown>,
-    opts?: WaterfallOptions,
-  ): Promise<unknown | null> {
-    const store = rowContext.getStore();
-    const toolName =
-      typeof toolNameOrSpec === 'string' ? toolNameOrSpec : toolNameOrSpec.id;
-    const baseQueueKey =
-      typeof toolNameOrSpec === 'string'
-        ? toolNameOrSpec
-        : `inline:${toolNameOrSpec.id}`;
-    const inlineSpec = isInlineWaterfallSpec(toolNameOrSpec)
-      ? toolNameOrSpec
-      : undefined;
-
-    if (this.pureMapExecutionActive && !store) {
-      throw new Error(
-        'ctx.waterfall() cannot run inside the pure-JS fast path. Call it directly in the map definition so the batching runtime can stay enabled.',
-      );
-    }
-
-    if (!store) {
-      return this.executeWaterfallDirect(toolNameOrSpec, input, opts);
-    }
-
-    const rowId = store.rowId;
-    const fieldName = store.fieldName;
-    const queueKey = store.tableNamespace?.trim()
-      ? `${baseQueueKey}:${store.tableNamespace.trim()}`
-      : baseQueueKey;
-    const rowState = this.rowStates.get(rowId);
-    if (rowState && !rowState.waterfalls.has(toolName)) {
-      rowState.waterfalls.set(toolName, {
-        status: 'pending',
-        providerIndex: 0,
-      });
-    }
-
-    // Check if this was already resolved in a previous attempt (checkpoint)
-    const resolved = this.checkpoint.resolvedWaterfalls[queueKey];
-    if (resolved && rowId in resolved) {
-      this.log(`  Row ${rowId} ${toolName}: recovered from checkpoint`);
-      return resolved[rowId];
-    }
-
-    return new Promise((resolve) => {
-      const resolverId = `${rowId}-${queueKey}`;
-      this.resolvers.set(resolverId, resolve);
-
-      this.emitScopedFieldMetaUpdate({
-        rowId,
-        key: store?.rowKey ?? null,
-        tableNamespace: store?.tableNamespace ?? null,
-        fieldName,
-        status: 'running',
-        rowStatus: 'running',
-        stage: toolName,
-        provider: null,
-        error: null,
-        dataPatch: {},
-      });
-      if (inlineSpec) {
-        // Inline waterfalls have fully compiled child stages, so we can publish a
-        // real queued state for each step immediately instead of forcing the grid
-        // to guess from the row's broader status.
-        this.emitQueuedInlineWaterfallSteps(
-          rowId,
-          store?.rowKey ?? null,
-          store?.tableNamespace ?? null,
-          inlineSpec,
-        );
-      }
-
-      if (!this.waterfallQueue.has(queueKey)) {
-        this.waterfallQueue.set(queueKey, []);
-      }
-      this.waterfallQueue.get(queueKey)!.push({
-        rowId,
-        fieldName,
-        tableNamespace: store?.tableNamespace,
-        rowKey: store?.rowKey ?? null,
-        key: queueKey,
-        toolName,
-        input,
-        providerIndex: 0,
-        opts,
-        description: normalizeStepDescription(opts?.description),
-        ...(inlineSpec ? { spec: inlineSpec } : {}),
-      });
-    });
-  }
-
   private async executeTool(
     key: string,
     toolId: string,
@@ -3520,17 +3396,16 @@ export class PlayContextImpl {
     options?: ToolCallOptions,
   ): Promise<unknown> {
     const normalizedKey = this.normalizeContextKey(key, 'tool');
+    const toolCachePolicy = this.effectiveToolCallCachePolicy(options);
     const toolRequestIdentity = deriveToolRequestIdentity({
       toolId,
       requestInput: input,
     });
-    const directCallId = [
-      'direct',
-      normalizedKey,
+    const durableCacheKey = await this.durableToolCallCacheKey({
       toolId,
-      toolRequestIdentity,
-    ].join(':');
-
+      requestInput: input,
+      staleAfterSeconds: toolCachePolicy.staleAfterSeconds,
+    });
     const eventWaitHandler =
       (await this.#options.getIntegrationEventWaitHandler?.(toolId)) ?? null;
     const store = rowContext.getStore();
@@ -3557,13 +3432,8 @@ export class PlayContextImpl {
       }
 
       if (!store) {
-        const directRowId = -(this.directToolCallIndex + 1);
-        this.directToolCallIndex += 1;
-        const directCacheKey = this.buildToolResultCacheKey({
-          rowId: directRowId,
-          callId: directCallId,
-        });
-        const cached = options?.force
+        const directCacheKey = durableCacheKey;
+        const cached = toolCachePolicy.force
           ? null
           : this.getCachedToolResult(toolId, directCacheKey);
         if (cached?.done) {
@@ -3572,9 +3442,10 @@ export class PlayContextImpl {
             toolId,
             status: cached.result == null ? 'no_result' : 'completed',
             result: cached.result,
-            cached: true,
-            source: 'checkpoint',
-            cacheKey: directCacheKey,
+            execution: toolExecutionMetadataForOutcome({
+              kind: 'checkpoint',
+              cacheKey: directCacheKey,
+            }),
           });
         }
         this.log(`Calling tool: ${toolId}`);
@@ -3586,9 +3457,10 @@ export class PlayContextImpl {
           result: execution.result,
           metadata: execution.metadata,
           meta: execution.meta,
-          cached: false,
-          source: 'live',
-          cacheKey: directCacheKey,
+          execution: toolExecutionMetadataForOutcome({
+            kind: 'live',
+            cacheKey: directCacheKey,
+          }),
         });
         this.checkpoint.completedToolBatches[toolId] = {
           ...(this.checkpoint.completedToolBatches[toolId] ?? {}),
@@ -3617,13 +3489,8 @@ export class PlayContextImpl {
         );
       }
 
-      const toolResultCacheKey = this.buildToolResultCacheKey({
-        rowId,
-        tableNamespace: store.tableNamespace,
-        rowKey: store.rowKey,
-        callId,
-      });
-      const cached = options?.force
+      const toolResultCacheKey = durableCacheKey;
+      const cached = toolCachePolicy.force
         ? null
         : this.getCachedToolResult(toolId, toolResultCacheKey);
       if (cached?.done) {
@@ -3632,9 +3499,10 @@ export class PlayContextImpl {
           toolId,
           status: cached.result == null ? 'no_result' : 'completed',
           result: cached.result,
-          cached: true,
-          source: 'checkpoint',
-          cacheKey: toolResultCacheKey,
+          execution: toolExecutionMetadataForOutcome({
+            kind: 'checkpoint',
+            cacheKey: toolResultCacheKey,
+          }),
         });
       }
 
@@ -3660,6 +3528,9 @@ export class PlayContextImpl {
         });
         this.toolCallQueue.push({
           callId,
+          cacheKey: toolResultCacheKey,
+          receiptKey: durableCacheKey,
+          force: toolCachePolicy.force,
           rowId,
           fieldName,
           toolId,
@@ -3680,15 +3551,28 @@ export class PlayContextImpl {
       normalizedKey,
       this.currentRunId,
       {
+        receiptKey: durableCacheKey,
         semanticKey: toolRequestIdentity,
-        force: options?.force === true,
-        repairRunningReceiptForSameRun: true,
-        staleAfterSeconds: options?.staleAfterSeconds,
+        force: toolCachePolicy.force,
+        staleAfterSeconds: toolCachePolicy.staleAfterSeconds,
         markSkipped: () => {
           this.log(
             `ctx.tools.execute(${toolId}): no-op due completed receipt ${toolRequestIdentity} (label: ${normalizedKey})`,
           );
         },
+        onClaimedResult: (output, receiptKey) =>
+          markToolExecuteResultExecutionOutcome(output, {
+            kind: 'live',
+            receiptKey,
+          }),
+        onRecovered: (output, _receipt, source) =>
+          markToolExecuteResultExecutionOutcome(
+            output,
+            toolExecutionOutcomeForDurableReceipt({
+              source,
+              receiptKey: durableCacheKey,
+            }),
+          ),
         execute: executeTool,
       },
     );
@@ -3743,9 +3627,10 @@ export class PlayContextImpl {
         toolId,
         status: 'completed',
         result: existing.output,
-        cached: true,
-        source: 'checkpoint',
-        cacheKey: `integration_event:${preparedBoundary.boundaryId}`,
+        execution: toolExecutionMetadataForOutcome({
+          kind: 'checkpoint',
+          cacheKey: `integration_event:${preparedBoundary.boundaryId}`,
+        }),
       });
     }
 
@@ -3880,9 +3765,13 @@ export class PlayContextImpl {
           checkpoint: this.checkpoint,
           governance: childGovernance,
           getRuntimeStepReceipt: undefined,
+          getRuntimeStepReceipts: undefined,
           claimRuntimeStepReceipt: undefined,
+          claimRuntimeStepReceipts: undefined,
           completeRuntimeStepReceipt: undefined,
+          completeRuntimeStepReceipts: undefined,
           failRuntimeStepReceipt: undefined,
+          failRuntimeStepReceipts: undefined,
           skipRuntimeStepReceipt: undefined,
         });
         const childExecution = this.executeResolvedPlay(
@@ -3957,13 +3846,13 @@ export class PlayContextImpl {
             input,
           }),
         ),
-        repairRunningReceiptForSameRun: true,
         staleAfterSeconds: options?.staleAfterSeconds,
         markSkipped: () => {
           this.log(
             `ctx.runPlay(${normalizedKey}): no-op due completed receipt`,
           );
         },
+        repairRunningReceiptForSameRunAfterWaitTimeout: true,
         execute: executePlayCall,
       },
     );
@@ -4273,16 +4162,23 @@ export class PlayContextImpl {
       return output;
     };
 
-    if (rowStore) {
-      return await executeStep();
-    }
-
     return this.executeWithRuntimeReceipt<T>(
       'step',
       normalizedKey,
       this.currentRunId,
       {
-        semanticKey: options?.semanticKey,
+        semanticKey: rowStore
+          ? stableDigest(
+              stableStringify({
+                scope: 'row',
+                tableNamespace: rowStore.tableNamespace ?? null,
+                rowKey: rowStore.rowKey ?? null,
+                rowId: rowStore.rowKey ? null : rowStore.rowId,
+                fieldName: rowStore.fieldName ?? null,
+                callIndex,
+              }),
+            )
+          : options?.semanticKey,
         staleAfterSeconds: options?.staleAfterSeconds,
         markSkipped: (output) => {
           this.log(`ctx.step(${normalizedKey}): no-op due completed receipt`);
@@ -4324,809 +4220,11 @@ export class PlayContextImpl {
   }
 
   getStats(): Record<string, unknown> {
-    const stats: Record<
-      string,
-      { total: number; complete: number; failed: number }
-    > = {};
-    for (const [, rowState] of this.rowStates) {
-      for (const [toolName, wState] of rowState.waterfalls) {
-        if (!stats[toolName])
-          stats[toolName] = { total: 0, complete: 0, failed: 0 };
-        stats[toolName].total++;
-        if (wState.status === 'complete') stats[toolName].complete++;
-        if (wState.status === 'failed') stats[toolName].failed++;
-      }
-    }
     return {
       rowsProcessed: Math.max(this.rowStates.size, this.processedRowCount),
-      waterfalls: stats,
     };
   }
 
-  // ——— Batched waterfall execution (the core engine) ———
-
-  private async executeBatchedWaterfalls(): Promise<void> {
-    const queuedWaterfalls = this.waterfallQueue;
-    this.waterfallQueue = new Map();
-    this.log(`Executing batched waterfalls for ${queuedWaterfalls.size} tools`);
-
-    for (const [queueKey, requests] of queuedWaterfalls) {
-      const inlineSpec = requests[0]?.spec;
-      if (inlineSpec) {
-        await this.executeInlineWaterfall(queueKey, inlineSpec, requests);
-        continue;
-      }
-
-      const toolName = requests[0]?.toolName ?? queueKey;
-      const providers = requests[0]?.opts?.providers ?? [
-        'hunter',
-        'leadmagic',
-        'pdl',
-        'dropcontact',
-        'prospeo',
-      ];
-
-      this.log(
-        `Processing waterfall ${toolName}: ${requests.length} rows, providers: ${providers.join(', ')}`,
-      );
-
-      if (!this.checkpoint.resolvedWaterfalls[queueKey]) {
-        this.checkpoint.resolvedWaterfalls[queueKey] = {};
-      }
-
-      await executeWaterfallProviders<WaterfallRequest, unknown>({
-        providers,
-        getPendingRequests: () =>
-          requests.filter((req) => {
-            const wState = this.rowStates
-              .get(req.rowId)
-              ?.waterfalls.get(toolName);
-            return wState?.status === 'pending';
-          }),
-        getCachedResults: (provider) => {
-          const batchKey = `${queueKey}:${provider}`;
-          const cached = this.checkpoint.completedBatches[batchKey];
-          if (!cached) return null;
-          this.log(`  ${provider}: skipping (recovered from checkpoint)`);
-          return cached.map((entry) => ({
-            request: requests.find((request) => request.rowId === entry.rowId)!,
-            result: entry.result,
-          }));
-        },
-        storeCachedResults: (provider, results) => {
-          const batchKey = `${queueKey}:${provider}`;
-          this.checkpoint.completedBatches[batchKey] = results.map((entry) => ({
-            rowId: entry.request.rowId,
-            result: entry.result,
-          }));
-        },
-        executeProviderRequests: async (provider, pending) => {
-          const providerToolId = resolveWaterfallToolId(provider, toolName);
-          const strategy =
-            this.#options.getBatchOperationStrategy?.(providerToolId) ?? null;
-          this.log(`  ${provider}: ${pending.length} pending rows`);
-          this.governor.chargeBudget('retry', pending.length);
-
-          if (strategy) {
-            const compiledBatches = compileRequestsWithStrategy({
-              requests: pending,
-              strategy,
-              getPayload: (request: WaterfallRequest) => request.input,
-            });
-            const flattenedResults: Array<{
-              request: WaterfallRequest;
-              result: unknown | null;
-            }> = [];
-
-            await executeChunkedRequests({
-              requests: compiledBatches,
-              batchSize:
-                compiledBatches.length > 0
-                  ? await this.governor.suggestedParallelism(
-                      compiledBatches[0]!.batchOperation,
-                      4,
-                    )
-                  : 4,
-              execute: async (batch) =>
-                await this.callToolAPI(
-                  batch.batchOperation,
-                  batch.batchPayload,
-                ),
-              onRequestError: (batch, error) => {
-                this.log(
-                  `  ${provider}: batch of ${batch.memberRequests.length} request(s) failed: ` +
-                    `${formatChunkExecutionError(error)} (rows recorded as misses; the waterfall continues)`,
-                );
-              },
-              onChunkComplete: async (chunkResults) => {
-                for (const entry of chunkResults) {
-                  const splitResults =
-                    entry.result != null
-                      ? entry.request.splitResults(entry.result)
-                      : entry.request.memberRequests.map(() => null);
-
-                  for (
-                    let index = 0;
-                    index < entry.request.memberRequests.length;
-                    index += 1
-                  ) {
-                    flattenedResults.push({
-                      request: entry.request.memberRequests[index]!,
-                      result: splitResults[index] ?? null,
-                    });
-                  }
-                }
-                this.#options.onBatchComplete?.(this.checkpoint);
-              },
-            });
-
-            return flattenedResults;
-          }
-
-          const chunkResults: Array<{
-            request: WaterfallRequest;
-            result: unknown | null;
-          }> = [];
-          await executeChunkedRequests<WaterfallRequest, unknown>({
-            requests: pending,
-            batchSize: await this.governor.suggestedParallelism(
-              providerToolId,
-              50,
-            ),
-            execute: async (request) =>
-              await this.callToolAPI(providerToolId, request.input),
-            onRequestError: (request, error) => {
-              this.log(
-                `  ${provider}: row ${request.rowId} failed: ` +
-                  `${formatChunkExecutionError(error)} (recorded as a miss; the waterfall continues)`,
-              );
-            },
-            onChunkComplete: async (results) => {
-              chunkResults.push(...results);
-              this.#options.onBatchComplete?.(this.checkpoint);
-            },
-          });
-          return chunkResults;
-        },
-        onHit: (provider, request, result) => {
-          this.resolveWaterfall(
-            queueKey,
-            toolName,
-            request.rowId,
-            result,
-            provider,
-            request.rowKey ?? null,
-            request.tableNamespace ?? null,
-            request.fieldName,
-          );
-        },
-        onMiss: (_provider, request) => {
-          const wState = this.rowStates
-            .get(request.rowId)
-            ?.waterfalls.get(toolName);
-          if (wState) wState.providerIndex++;
-          this.log(`    Row ${request.rowId}: miss`);
-        },
-        onProviderComplete: () => {
-          this.#options.onBatchComplete?.(this.checkpoint);
-        },
-      });
-
-      const stepResults: PlayStepRowResult[] = requests.map((req) => {
-        const wState = this.rowStates.get(req.rowId)?.waterfalls.get(toolName);
-        const success = wState?.status === 'complete';
-        return {
-          rowId: req.rowId,
-          status: success ? 'completed' : 'missed',
-          success,
-          value: wState?.result,
-          error: success ? null : (wState?.error ?? null),
-        };
-      });
-      const waterfallStep = {
-        type: 'waterfall' as const,
-        tool: toolName,
-        providers,
-        results: stepResults,
-        description: normalizeStepDescription(requests[0]?.description),
-      };
-      if (this.activeDatasetStep) {
-        this.activeDatasetStep.substeps.push(waterfallStep);
-      } else {
-        this.steps.push(waterfallStep);
-      }
-
-      for (const req of requests) {
-        const wState = this.rowStates.get(req.rowId)?.waterfalls.get(toolName);
-        if (wState?.status === 'pending') {
-          wState.status = 'failed';
-          wState.error = 'All providers exhausted';
-          this.checkpoint.resolvedWaterfalls[queueKey]![req.rowId] = null;
-
-          const resolver = this.resolvers.get(`${req.rowId}-${queueKey}`);
-          if (resolver) {
-            resolver(null);
-            this.resolvers.delete(`${req.rowId}-${queueKey}`);
-          }
-          this.emitScopedFieldMetaUpdate({
-            rowId: req.rowId,
-            key: req.rowKey ?? null,
-            tableNamespace: req.tableNamespace ?? null,
-            fieldName: req.fieldName,
-            status: 'failed',
-            rowStatus: 'running',
-            stage: toolName,
-            provider: null,
-            error: 'All providers exhausted',
-            dataPatch: {},
-          });
-          this.log(`    Row ${req.rowId}: all providers exhausted`);
-        }
-      }
-    }
-  }
-
-  private async executeInlineWaterfall(
-    queueKey: string,
-    spec: InlineWaterfallSpec,
-    requests: WaterfallRequest[],
-  ): Promise<void> {
-    if (!this.checkpoint.resolvedWaterfalls[queueKey]) {
-      this.checkpoint.resolvedWaterfalls[queueKey] = {};
-    }
-
-    const pendingRows = new Set<number>(
-      requests
-        .filter(
-          (req) =>
-            this.rowStates.get(req.rowId)?.waterfalls.get(spec.id)?.status ===
-            'pending',
-        )
-        .map((req) => req.rowId),
-    );
-    const resultsByRow = new Map<number, unknown[]>();
-    const stepResults: Array<{
-      id: string;
-      kind?: 'tool' | 'code';
-      toolId?: string;
-      results: PlayStepRowResult[];
-    }> = [];
-    const stepColumnNames = spec.steps.map((s) =>
-      sqlSafePlayColumnName(`${spec.id}.${s.id}`),
-    );
-    const resolvedInChunkRowIds = new Set<number>();
-    let stepIdx = 0;
-
-    for (const step of spec.steps) {
-      const stepColumnName = sqlSafePlayColumnName(`${spec.id}.${step.id}`);
-      const stepProvider = isInlineWaterfallToolStep(step)
-        ? step.toolId
-        : 'code';
-      if (pendingRows.size === 0) {
-        const skippedResults: PlayStepRowResult[] = requests.map((request) => {
-          this.emitCellUpdate({
-            rowId: request.rowId,
-            key: request.rowKey ?? null,
-            tableNamespace: request.tableNamespace ?? null,
-            columnName: stepColumnName,
-            status: 'skipped',
-            stage: step.id,
-            provider: stepProvider,
-            value: null,
-          });
-          return {
-            rowId: request.rowId,
-            status: 'skipped',
-            success: false,
-            value: null,
-            error: null,
-          };
-        });
-        stepResults.push({
-          id: step.id,
-          kind: isInlineWaterfallCodeStep(step) ? 'code' : 'tool',
-          toolId: stepProvider,
-          results: skippedResults,
-        });
-        stepIdx++;
-        continue;
-      }
-      this.governor.chargeBudget('waterfallStep', pendingRows.size);
-      const pendingRowIds = new Set<number>(pendingRows);
-      const stepRequests = requests.filter((req) =>
-        pendingRowIds.has(req.rowId),
-      );
-      const perRowResultsByRowId = new Map<number, PlayStepRowResult>();
-      if (isInlineWaterfallCodeStep(step)) {
-        this.log(
-          `  Inline waterfall ${spec.id} -> ${step.id}: ${stepRequests.length} pending rows (code)`,
-        );
-        await executeChunkedRequests<WaterfallRequest, unknown>({
-          requests: stepRequests,
-          batchSize: await this.governor.suggestedParallelism(
-            `code:${spec.id}:${step.id}`,
-            20,
-          ),
-          onRequestError: (request, error) => {
-            this.log(
-              `  Inline waterfall ${spec.id} -> ${step.id}: row ${request.rowId} failed: ` +
-                `${formatChunkExecutionError(error)} (recorded as a miss; the waterfall continues)`,
-            );
-          },
-          execute: async (request) => {
-            const codeStepCtx = {
-              tools: {
-                execute: async (
-                  requestOrKey:
-                    | { tool: string; input: Record<string, unknown> }
-                    | string,
-                  toolId?: string,
-                  payload?: Record<string, unknown>,
-                ) => {
-                  if (typeof requestOrKey === 'object') {
-                    return await this.callToolAPI(
-                      requestOrKey.tool,
-                      requestOrKey.input,
-                    );
-                  }
-                  if (!toolId || !payload) {
-                    throw new Error(
-                      'inline waterfall ctx.tools.execute requires a tool and input.',
-                    );
-                  }
-                  return await this.callToolAPI(toolId, payload);
-                },
-              },
-            };
-            return await step.run(request.input, codeStepCtx);
-          },
-          onChunkComplete: async (chunkResults) => {
-            for (const entry of chunkResults) {
-              const matchedValue = extractInlineWaterfallCodeStepValue(
-                spec.output,
-                entry.result,
-              );
-              const bucket = resultsByRow.get(entry.request.rowId) ?? [];
-              const nextBucket = Array.isArray(matchedValue)
-                ? [...bucket, ...matchedValue]
-                : matchedValue != null
-                  ? [...bucket, matchedValue]
-                  : bucket;
-              resultsByRow.set(entry.request.rowId, nextBucket);
-              const satisfied = nextBucket.length >= spec.minResults;
-              perRowResultsByRowId.set(entry.request.rowId, {
-                rowId: entry.request.rowId,
-                status: matchedValue != null ? 'completed' : 'missed',
-                success: matchedValue != null,
-                value: matchedValue,
-                provider: matchedValue != null ? 'code' : undefined,
-                error: null,
-              });
-              if (satisfied) {
-                const finalValue =
-                  spec.minResults === 1 ? (nextBucket[0] ?? null) : nextBucket;
-                this.resolveWaterfall(
-                  queueKey,
-                  spec.id,
-                  entry.request.rowId,
-                  finalValue,
-                  'code',
-                  entry.request.rowKey ?? null,
-                  entry.request.tableNamespace ?? null,
-                  entry.request.fieldName,
-                );
-                pendingRows.delete(entry.request.rowId);
-                this.emitCellUpdate({
-                  rowId: entry.request.rowId,
-                  key: entry.request.rowKey ?? null,
-                  tableNamespace: entry.request.tableNamespace ?? null,
-                  columnName: stepColumnName,
-                  status: 'completed',
-                  stage: step.id,
-                  provider: 'code',
-                  value: matchedValue,
-                });
-                for (let ri = stepIdx + 1; ri < spec.steps.length; ri++) {
-                  const skippedStep = spec.steps[ri]!;
-                  this.emitCellUpdate({
-                    rowId: entry.request.rowId,
-                    key: entry.request.rowKey ?? null,
-                    tableNamespace: entry.request.tableNamespace ?? null,
-                    columnName: stepColumnNames[ri]!,
-                    status: 'skipped',
-                    stage: skippedStep.id,
-                    provider: isInlineWaterfallToolStep(skippedStep)
-                      ? skippedStep.toolId
-                      : 'code',
-                    value: null,
-                  });
-                }
-                resolvedInChunkRowIds.add(entry.request.rowId);
-              }
-            }
-            this.#options.onBatchComplete?.(this.checkpoint);
-          },
-        });
-      } else {
-        const strategy =
-          this.#options.getBatchOperationStrategy?.(step.toolId) ?? null;
-        this.log(
-          `  Inline waterfall ${spec.id} -> ${step.id}: ${stepRequests.length} pending rows`,
-        );
-        for (const request of stepRequests) {
-          this.emitCellUpdate({
-            rowId: request.rowId,
-            key: request.rowKey ?? null,
-            tableNamespace: request.tableNamespace ?? null,
-            columnName: stepColumnName,
-            status: 'running',
-            stage: step.id,
-            provider: step.toolId,
-            value: null,
-          });
-        }
-
-        if (strategy) {
-          const compiledBatches = compileRequestsWithStrategy({
-            requests: stepRequests,
-            strategy,
-            getPayload: (request: WaterfallRequest) =>
-              step.mapInput(request.input),
-          });
-          this.log(
-            `    ${step.toolId}: compiled ${compiledBatches.length} batch request(s)` +
-              ` (${this.summarizeBatchSizes(
-                compiledBatches.map((batch) => batch.memberRequests.length),
-              )})`,
-          );
-          await executeChunkedRequests({
-            requests: compiledBatches,
-            batchSize:
-              compiledBatches.length > 0
-                ? await this.governor.suggestedParallelism(
-                    compiledBatches[0]!.batchOperation,
-                    4,
-                  )
-                : 4,
-            execute: async (batch) =>
-              await this.callToolAPI(batch.batchOperation, batch.batchPayload),
-            onRequestError: (batch, error) => {
-              this.log(
-                `    ${step.toolId}: batch of ${batch.memberRequests.length} request(s) failed: ` +
-                  `${formatChunkExecutionError(error)} (rows recorded as misses; the waterfall continues)`,
-              );
-            },
-            onChunkComplete: async (chunkResults) => {
-              for (const entry of chunkResults) {
-                const splitResults =
-                  entry.result != null
-                    ? entry.request.splitResults(entry.result)
-                    : entry.request.memberRequests.map(() => null);
-                for (
-                  let index = 0;
-                  index < entry.request.memberRequests.length;
-                  index += 1
-                ) {
-                  const request = entry.request.memberRequests[index]!;
-                  const rawResult = splitResults[index] ?? null;
-                  const matchedValue = await extractWaterfallOutputValue(
-                    step.toolId,
-                    spec.output,
-                    rawResult,
-                    this.#options.getToolTargetGetters,
-                  );
-                  const bucket = resultsByRow.get(request.rowId) ?? [];
-                  const nextBucket = Array.isArray(matchedValue)
-                    ? [...bucket, ...matchedValue]
-                    : matchedValue != null
-                      ? [...bucket, matchedValue]
-                      : bucket;
-                  resultsByRow.set(request.rowId, nextBucket);
-                  const satisfied = nextBucket.length >= spec.minResults;
-                  perRowResultsByRowId.set(request.rowId, {
-                    rowId: request.rowId,
-                    status: matchedValue != null ? 'completed' : 'missed',
-                    success: matchedValue != null,
-                    value: matchedValue,
-                    provider: matchedValue != null ? step.toolId : undefined,
-                    error: null,
-                  });
-                  if (satisfied) {
-                    const finalValue =
-                      spec.minResults === 1
-                        ? (nextBucket[0] ?? null)
-                        : nextBucket;
-                    this.resolveWaterfall(
-                      queueKey,
-                      spec.id,
-                      request.rowId,
-                      finalValue,
-                      step.toolId,
-                      request.rowKey ?? null,
-                      request.tableNamespace ?? null,
-                      request.fieldName,
-                    );
-                    pendingRows.delete(request.rowId);
-                    this.emitCellUpdate({
-                      rowId: request.rowId,
-                      key: request.rowKey ?? null,
-                      tableNamespace: request.tableNamespace ?? null,
-                      columnName: stepColumnNames[stepIdx]!,
-                      status: 'completed',
-                      stage: step.id,
-                      provider: step.toolId,
-                      value: matchedValue,
-                    });
-                    for (let ri = stepIdx + 1; ri < spec.steps.length; ri++) {
-                      const skippedStep = spec.steps[ri]!;
-                      this.emitCellUpdate({
-                        rowId: request.rowId,
-                        key: request.rowKey ?? null,
-                        tableNamespace: request.tableNamespace ?? null,
-                        columnName: stepColumnNames[ri]!,
-                        status: 'skipped',
-                        stage: skippedStep.id,
-                        provider: isInlineWaterfallToolStep(skippedStep)
-                          ? skippedStep.toolId
-                          : 'code',
-                        value: null,
-                      });
-                    }
-                    resolvedInChunkRowIds.add(request.rowId);
-                  }
-                }
-              }
-              this.#options.onBatchComplete?.(this.checkpoint);
-            },
-          });
-        } else {
-          this.log(
-            `    ${step.toolId}: executing ${stepRequests.length} unbatched request(s)`,
-          );
-          await executeChunkedRequests<WaterfallRequest, unknown>({
-            requests: stepRequests,
-            batchSize: await this.governor.suggestedParallelism(
-              step.toolId,
-              50,
-            ),
-            execute: async (request) =>
-              await this.callToolAPI(step.toolId, step.mapInput(request.input)),
-            onRequestError: (request, error) => {
-              this.log(
-                `    ${step.toolId}: row ${request.rowId} failed: ` +
-                  `${formatChunkExecutionError(error)} (recorded as a miss; the waterfall continues)`,
-              );
-            },
-            onChunkComplete: async (chunkResults) => {
-              for (const entry of chunkResults) {
-                const matchedValue = await extractWaterfallOutputValue(
-                  step.toolId,
-                  spec.output,
-                  entry.result,
-                  this.#options.getToolTargetGetters,
-                );
-                const bucket = resultsByRow.get(entry.request.rowId) ?? [];
-                const nextBucket = Array.isArray(matchedValue)
-                  ? [...bucket, ...matchedValue]
-                  : matchedValue != null
-                    ? [...bucket, matchedValue]
-                    : bucket;
-                resultsByRow.set(entry.request.rowId, nextBucket);
-                const satisfied = nextBucket.length >= spec.minResults;
-                perRowResultsByRowId.set(entry.request.rowId, {
-                  rowId: entry.request.rowId,
-                  status: matchedValue != null ? 'completed' : 'missed',
-                  success: matchedValue != null,
-                  value: matchedValue,
-                  provider: matchedValue != null ? step.toolId : undefined,
-                  error: null,
-                });
-                if (satisfied) {
-                  const finalValue =
-                    spec.minResults === 1
-                      ? (nextBucket[0] ?? null)
-                      : nextBucket;
-                  this.resolveWaterfall(
-                    queueKey,
-                    spec.id,
-                    entry.request.rowId,
-                    finalValue,
-                    step.toolId,
-                    entry.request.rowKey ?? null,
-                    entry.request.tableNamespace ?? null,
-                    entry.request.fieldName,
-                  );
-                  pendingRows.delete(entry.request.rowId);
-                  this.emitCellUpdate({
-                    rowId: entry.request.rowId,
-                    key: entry.request.rowKey ?? null,
-                    tableNamespace: entry.request.tableNamespace ?? null,
-                    columnName: stepColumnNames[stepIdx]!,
-                    status: 'completed',
-                    stage: step.id,
-                    provider: step.toolId,
-                    value: matchedValue,
-                  });
-                  for (let ri = stepIdx + 1; ri < spec.steps.length; ri++) {
-                    const skippedStep = spec.steps[ri]!;
-                    this.emitCellUpdate({
-                      rowId: entry.request.rowId,
-                      key: entry.request.rowKey ?? null,
-                      tableNamespace: entry.request.tableNamespace ?? null,
-                      columnName: stepColumnNames[ri]!,
-                      status: 'skipped',
-                      stage: skippedStep.id,
-                      provider: isInlineWaterfallToolStep(skippedStep)
-                        ? skippedStep.toolId
-                        : 'code',
-                      value: null,
-                    });
-                  }
-                  resolvedInChunkRowIds.add(entry.request.rowId);
-                }
-              }
-              this.#options.onBatchComplete?.(this.checkpoint);
-            },
-          });
-        }
-      }
-
-      const perRowResults: PlayStepRowResult[] = requests.map((request) => {
-        if (resolvedInChunkRowIds.has(request.rowId)) {
-          const existing = perRowResultsByRowId.get(request.rowId);
-          return (
-            existing ?? {
-              rowId: request.rowId,
-              status: 'completed' as const,
-              success: true,
-              value: null,
-              error: null,
-            }
-          );
-        }
-        const existing = perRowResultsByRowId.get(request.rowId);
-        if (existing) {
-          this.emitCellUpdate({
-            rowId: request.rowId,
-            key: request.rowKey ?? null,
-            tableNamespace: request.tableNamespace ?? null,
-            columnName: stepColumnName,
-            status: existing.status,
-            stage: step.id,
-            provider: existing.provider ?? stepProvider,
-            error: existing.error ?? null,
-            value: existing.value ?? null,
-          });
-          return existing;
-        }
-        if (!pendingRowIds.has(request.rowId)) {
-          this.emitCellUpdate({
-            rowId: request.rowId,
-            key: request.rowKey ?? null,
-            tableNamespace: request.tableNamespace ?? null,
-            columnName: stepColumnName,
-            status: 'skipped',
-            stage: step.id,
-            provider: stepProvider,
-            value: null,
-          });
-          return {
-            rowId: request.rowId,
-            status: 'skipped',
-            success: false,
-            value: null,
-            error: null,
-          };
-        }
-        this.emitCellUpdate({
-          rowId: request.rowId,
-          key: request.rowKey ?? null,
-          tableNamespace: request.tableNamespace ?? null,
-          columnName: stepColumnName,
-          status: 'missed',
-          stage: step.id,
-          provider: stepProvider,
-          value: null,
-        });
-        return {
-          rowId: request.rowId,
-          status: 'missed',
-          success: false,
-          value: null,
-          error: null,
-        };
-      });
-
-      stepResults.push({
-        id: step.id,
-        kind: isInlineWaterfallCodeStep(step) ? 'code' : 'tool',
-        toolId: stepProvider,
-        // Persist only a bounded preview in the in-memory execution trace.
-        // The authoritative per-row state already lives in Neon/live progress.
-        results: compactRowResultsPreview(perRowResults),
-      });
-      stepIdx++;
-    }
-
-    for (const req of requests) {
-      const wState = this.rowStates.get(req.rowId)?.waterfalls.get(spec.id);
-      if (wState?.status === 'pending') {
-        wState.status = 'failed';
-        wState.error = 'All waterfall steps exhausted';
-        this.checkpoint.resolvedWaterfalls[queueKey]![req.rowId] = null;
-        const resolver = this.resolvers.get(`${req.rowId}-${queueKey}`);
-        if (resolver) {
-          resolver(null);
-          this.resolvers.delete(`${req.rowId}-${queueKey}`);
-        }
-      }
-    }
-
-    const groupResults: PlayStepRowResult[] = requests.map((req) => {
-      const wState = this.rowStates.get(req.rowId)?.waterfalls.get(spec.id);
-      const success = wState?.status === 'complete';
-      return {
-        rowId: req.rowId,
-        status: success ? 'completed' : 'missed',
-        success,
-        value: wState?.result,
-        error: success ? null : (wState?.error ?? null),
-      };
-    });
-
-    const waterfallStep = {
-      type: 'waterfall' as const,
-      id: spec.id,
-      output: spec.output,
-      minResults: spec.minResults,
-      steps: stepResults,
-      results: compactRowResultsPreview(groupResults),
-      description: normalizeStepDescription(requests[0]?.description),
-    };
-    if (this.activeDatasetStep) {
-      this.activeDatasetStep.substeps.push(waterfallStep);
-    } else {
-      this.steps.push(waterfallStep);
-    }
-  }
-
-  private resolveWaterfall(
-    queueKey: string,
-    toolName: string,
-    rowId: number,
-    result: unknown,
-    provider: string,
-    rowKey: string | null,
-    tableNamespace: string | null,
-    fieldName?: string,
-  ): void {
-    const wState = this.rowStates.get(rowId)?.waterfalls.get(toolName);
-    if (!wState || wState.status !== 'pending') return;
-
-    wState.status = 'complete';
-    wState.result = result;
-    this.checkpoint.resolvedWaterfalls[queueKey]![rowId] = result;
-
-    const resolver = this.resolvers.get(`${rowId}-${queueKey}`);
-    if (resolver) {
-      resolver(result);
-      this.resolvers.delete(`${rowId}-${queueKey}`);
-    }
-    this.emitScopedFieldMetaUpdate({
-      rowId,
-      key: rowKey,
-      tableNamespace,
-      fieldName,
-      status: 'running',
-      rowStatus: 'running',
-      stage: toolName,
-      provider,
-      error: null,
-      dataPatch: {},
-    });
-    this.logWaterfallMatch({ queueKey, rowId, provider });
-  }
-
   // ——— Batched tool call execution ———
 
   private async executeBatchedToolCalls(): Promise<void> {
@@ -5147,15 +4245,7 @@ export class PlayContextImpl {
         const recordToolStep = (stepRequests: ToolCallRequest[]): void => {
           if (stepRequests.length === 0) return;
           const stepResults: PlayStepRowResult[] = stepRequests.map((req) => {
-            const cachedResult = this.getCachedToolResult(
-              toolId,
-              this.buildToolResultCacheKey({
-                rowId: req.rowId,
-                tableNamespace: req.tableNamespace,
-                rowKey: req.rowKey ?? undefined,
-                callId: req.callId,
-              }),
-            );
+            const cachedResult = this.getCachedToolResult(toolId, req.cacheKey);
             return {
               rowId: req.rowId,
               status: cachedResult?.result != null ? 'completed' : 'failed',
@@ -5181,15 +4271,7 @@ export class PlayContextImpl {
         const pendingRequests: ToolCallRequest[] = [];
         const recoveredRequests: ToolCallRequest[] = [];
         for (const req of requests) {
-          const cached = this.getCachedToolResult(
-            toolId,
-            this.buildToolResultCacheKey({
-              rowId: req.rowId,
-              tableNamespace: req.tableNamespace,
-              rowKey: req.rowKey ?? undefined,
-              callId: req.callId,
-            }),
-          );
+          const cached = this.getCachedToolResult(toolId, req.cacheKey);
           if (cached?.done) {
             this.log(`  Row ${req.rowId} ${toolId}: recovered from checkpoint`);
             const resolver = this.toolCallResolvers.get(req.callId);
@@ -5204,6 +4286,240 @@ export class PlayContextImpl {
         }
         recordToolStep(recoveredRequests);
 
+        const liveFollowersByOwnerCallId = new Map<string, ToolCallRequest[]>();
+        const resolveLiveFollowers = (
+          owner: ToolCallRequest,
+          result: unknown,
+        ): void => {
+          const followers = liveFollowersByOwnerCallId.get(owner.callId);
+          if (!followers || followers.length === 0) return;
+          liveFollowersByOwnerCallId.delete(owner.callId);
+          for (const follower of followers) {
+            const followerReceiptKey = follower.receiptKey?.trim() || null;
+            const followerResult = followerReceiptKey
+              ? markToolExecuteResultExecutionOutcome(result, {
+                  kind: 'in_flight',
+                  receiptKey: followerReceiptKey,
+                  attachedToReceiptKey: followerReceiptKey,
+                })
+              : result;
+            this.cacheToolResult(toolId, follower.cacheKey, followerResult);
+            const resolver = this.toolCallResolvers.get(follower.callId);
+            if (resolver) {
+              resolver.resolve(followerResult);
+              this.toolCallResolvers.delete(follower.callId);
+            }
+            this.emitScopedFieldMetaUpdate({
+              rowId: follower.rowId,
+              key: follower.rowKey ?? null,
+              tableNamespace: follower.tableNamespace ?? null,
+              fieldName: follower.fieldName,
+              status: 'cached',
+              rowStatus: 'running',
+              stage: toolId,
+              provider: null,
+              error: null,
+              reused: true,
+              dataPatch: {},
+            });
+          }
+        };
+        const rejectWithLiveFollowers = async (
+          owner: ToolCallRequest,
+          error: unknown,
+        ): Promise<void> => {
+          const followers = liveFollowersByOwnerCallId.get(owner.callId) ?? [];
+          liveFollowersByOwnerCallId.delete(owner.callId);
+          for (const request of [owner, ...followers]) {
+            await this.rejectToolCall(toolId, request, error);
+          }
+        };
+
+        const durableWaiters: Promise<void>[] = [];
+        if (
+          pendingRequests.length > 0 &&
+          (this.#options.claimRuntimeStepReceipts ||
+            this.#options.claimRuntimeStepReceipt)
+        ) {
+          const requestsByReceiptKey = new Map<
+            string,
+            { requests: ToolCallRequest[]; forceRefresh: boolean }
+          >();
+          const localOnlyRequests: ToolCallRequest[] = [];
+          for (const request of pendingRequests) {
+            const receiptKey = request.receiptKey?.trim() || null;
+            if (!receiptKey) {
+              localOnlyRequests.push(request);
+              continue;
+            }
+            const group = requestsByReceiptKey.get(receiptKey) ?? {
+              requests: [],
+              forceRefresh: false,
+            };
+            group.requests.push(request);
+            group.forceRefresh ||= request.force === true;
+            requestsByReceiptKey.set(receiptKey, group);
+          }
+          const normalReceiptKeys = [...requestsByReceiptKey]
+            .filter(([, group]) => !group.forceRefresh)
+            .map(([receiptKey]) => receiptKey);
+          const forcedReceiptKeys = [...requestsByReceiptKey]
+            .filter(([, group]) => group.forceRefresh)
+            .map(([receiptKey]) => receiptKey);
+          const claims =
+            normalReceiptKeys.length > 0
+              ? await this.claimRuntimeStepReceipts(
+                  normalReceiptKeys,
+                  this.currentRunId,
+                )
+              : new Map<string, RuntimeStepReceipt>();
+          const forcedClaims =
+            forcedReceiptKeys.length > 0
+              ? await this.claimRuntimeStepReceipts(
+                  forcedReceiptKeys,
+                  this.currentRunId,
+                  true,
+                  true,
+                )
+              : new Map<string, RuntimeStepReceipt>();
+          for (const [receiptKey, claim] of forcedClaims) {
+            claims.set(receiptKey, claim);
+          }
+          const claimedRequests: ToolCallRequest[] = [...localOnlyRequests];
+          const durableRecoveredRequests: ToolCallRequest[] = [];
+          const resolveRequestsFromReceipt = async (
+            requestsForKey: ToolCallRequest[],
+            receipt: RuntimeStepReceipt,
+            source: 'cache' | 'in_flight',
+          ): Promise<void> => {
+            const request = requestsForKey[0];
+            if (!request) return;
+            const receiptKey = request.receiptKey?.trim() || null;
+            if (!receiptKey) {
+              throw new Error(
+                `Durable tool receipt ${source} recovery requires a receipt key.`,
+              );
+            }
+            const wrapped = await this.wrapToolExecutionResult({
+              toolId,
+              status:
+                receipt.output === null || receipt.output === undefined
+                  ? 'no_result'
+                  : 'completed',
+              result: this.runtimeReceiptOutput(receipt),
+              execution: toolExecutionMetadataForOutcome({
+                kind: source,
+                cacheKey: request.cacheKey,
+                receiptKey,
+                attachedToReceiptKey: receiptKey,
+              }),
+            });
+            this.cacheToolResult(toolId, request.cacheKey, wrapped);
+            for (const waitingRequest of requestsForKey) {
+              const resolver = this.toolCallResolvers.get(
+                waitingRequest.callId,
+              );
+              if (resolver) {
+                resolver.resolve(wrapped);
+                this.toolCallResolvers.delete(waitingRequest.callId);
+              }
+              this.emitScopedFieldMetaUpdate({
+                rowId: waitingRequest.rowId,
+                key: waitingRequest.rowKey ?? null,
+                tableNamespace: waitingRequest.tableNamespace ?? null,
+                fieldName: waitingRequest.fieldName,
+                status: 'cached',
+                rowStatus: 'running',
+                stage: toolId,
+                provider: null,
+                error: null,
+                reused: true,
+                dataPatch: {},
+              });
+            }
+          };
+          const claimOwnerWithLiveFollowers = (
+            owner: ToolCallRequest | undefined,
+            followers: ToolCallRequest[],
+          ): void => {
+            if (!owner) return;
+            claimedRequests.push(owner);
+            if (followers.length > 0) {
+              liveFollowersByOwnerCallId.set(owner.callId, followers);
+            }
+          };
+          const waitForReceiptOrTimeout = async (
+            receiptKey: string,
+            requestsForKey: ToolCallRequest[],
+          ): Promise<void> => {
+            try {
+              await resolveRequestsFromReceipt(
+                requestsForKey,
+                await this.waitForCompletedRuntimeToolReceipt(receiptKey),
+                'in_flight',
+              );
+              return;
+            } catch (error) {
+              if (!(error instanceof RuntimeReceiptWaitTimeoutError)) {
+                for (const request of requestsForKey) {
+                  await this.rejectToolCall(toolId, request, error, {
+                    persistReceiptFailure: false,
+                  });
+                }
+                return;
+              }
+            }
+            for (const request of requestsForKey) {
+              await this.rejectToolCall(
+                toolId,
+                request,
+                new RuntimeReceiptWaitTimeoutError(receiptKey),
+                { persistReceiptFailure: false },
+              );
+            }
+          };
+
+          for (const [receiptKey, group] of requestsByReceiptKey) {
+            const requestsForKey = group.requests;
+            const claim = claims.get(receiptKey);
+            if (!claim) {
+              const [owner, ...waiters] = requestsForKey;
+              claimOwnerWithLiveFollowers(owner, waiters);
+              continue;
+            }
+            if (claim?.status === 'completed' || claim?.status === 'skipped') {
+              await resolveRequestsFromReceipt(requestsForKey, claim, 'cache');
+              durableRecoveredRequests.push(...requestsForKey);
+              continue;
+            }
+            if (claim?.status === 'failed') {
+              for (const request of requestsForKey) {
+                await this.rejectToolCall(
+                  toolId,
+                  request,
+                  new Error(claim.error ?? 'Durable tool call failed.'),
+                );
+              }
+              continue;
+            }
+            if (
+              claim?.status === 'running' &&
+              claim.claimState !== 'existing'
+            ) {
+              const [owner, ...waiters] = requestsForKey;
+              claimOwnerWithLiveFollowers(owner, waiters);
+              continue;
+            }
+            durableWaiters.push(
+              waitForReceiptOrTimeout(receiptKey, requestsForKey),
+            );
+          }
+
+          pendingRequests.length = 0;
+          pendingRequests.push(...claimedRequests);
+          recordToolStep(durableRecoveredRequests);
+        }
+
         if (pendingRequests.length > 0) {
           const strategy =
             this.#options.getBatchOperationStrategy?.(toolId) ?? null;
@@ -5234,7 +4550,7 @@ export class PlayContextImpl {
                 for (const entry of chunkResults) {
                   if (entry.error !== undefined) {
                     for (const request of entry.request.memberRequests) {
-                      this.rejectToolCall(toolId, request, entry.error);
+                      await rejectWithLiveFollowers(request, entry.error);
                     }
                     continue;
                   }
@@ -5242,6 +4558,14 @@ export class PlayContextImpl {
                     entry.result != null
                       ? entry.request.splitResults(entry.result)
                       : entry.request.memberRequests.map(() => null);
+                  const resolvedResults =
+                    await this.resolveToolCallBatchResults(
+                      toolId,
+                      entry.request.memberRequests.map((request, index) => ({
+                        request,
+                        result: splitResults[index] ?? null,
+                      })),
+                    );
 
                   for (
                     let index = 0;
@@ -5249,11 +4573,7 @@ export class PlayContextImpl {
                     index += 1
                   ) {
                     const request = entry.request.memberRequests[index]!;
-                    await this.resolveToolCall(
-                      toolId,
-                      request,
-                      splitResults[index] ?? null,
-                    );
+                    resolveLiveFollowers(request, resolvedResults[index]);
                   }
                 }
 
@@ -5281,7 +4601,7 @@ export class PlayContextImpl {
                       toolId,
                       request.input,
                     );
-                    await this.resolveToolCall(
+                    const result = await this.resolveToolCall(
                       toolId,
                       request,
                       execution?.result ?? null,
@@ -5289,8 +4609,9 @@ export class PlayContextImpl {
                       execution?.jobId,
                       execution?.meta,
                     );
+                    resolveLiveFollowers(request, result);
                   } catch (error) {
-                    this.rejectToolCall(toolId, request, error);
+                    await rejectWithLiveFollowers(request, error);
                   }
                 }),
               );
@@ -5300,6 +4621,9 @@ export class PlayContextImpl {
             }
           }
         }
+        if (durableWaiters.length > 0) {
+          await Promise.allSettled(durableWaiters);
+        }
       }),
     );
   }
@@ -5377,95 +4701,6 @@ export class PlayContextImpl {
     )(ctx, input);
   }
 
-  // ——— Direct execution (outside map context) ———
-
-  private async executeWaterfallDirect(
-    toolNameOrSpec: string | InlineWaterfallSpec,
-    input: Record<string, unknown>,
-    opts?: WaterfallOptions,
-  ): Promise<unknown | null> {
-    if (isInlineWaterfallSpec(toolNameOrSpec)) {
-      this.log(`Direct inline waterfall: ${toolNameOrSpec.id}`);
-      const collected: unknown[] = [];
-      for (const step of toolNameOrSpec.steps) {
-        this.governor.chargeBudget('waterfallStep');
-        const matched = isInlineWaterfallCodeStep(step)
-          ? extractInlineWaterfallCodeStepValue(
-              toolNameOrSpec.output,
-              await step.run(input, {
-                tools: {
-                  execute: async (
-                    requestOrKey:
-                      | { tool: string; input: Record<string, unknown> }
-                      | string,
-                    toolId?: string,
-                    payload?: Record<string, unknown>,
-                  ) => {
-                    if (typeof requestOrKey === 'object') {
-                      return await this.callToolAPI(
-                        requestOrKey.tool,
-                        requestOrKey.input,
-                      );
-                    }
-                    if (!toolId || !payload) {
-                      throw new Error(
-                        'inline waterfall ctx.tools.execute requires a tool and input.',
-                      );
-                    }
-                    return await this.callToolAPI(toolId, payload);
-                  },
-                },
-              }),
-            )
-          : await extractWaterfallOutputValue(
-              step.toolId,
-              toolNameOrSpec.output,
-              await this.callToolAPI(step.toolId, step.mapInput(input)),
-              this.#options.getToolTargetGetters,
-            );
-        if (Array.isArray(matched)) {
-          collected.push(...matched);
-        } else if (matched != null) {
-          collected.push(matched);
-        }
-        if (collected.length >= toolNameOrSpec.minResults) {
-          return toolNameOrSpec.minResults === 1
-            ? (collected[0] ?? null)
-            : collected;
-        }
-      }
-      return null;
-    }
-
-    const toolName = toolNameOrSpec;
-    this.log(`Direct waterfall: ${toolName}`);
-    const providers = opts?.providers ?? ['hunter', 'leadmagic', 'pdl'];
-
-    for (const provider of providers) {
-      this.log(`  Trying ${provider}`);
-      try {
-        this.governor.chargeBudget('retry');
-        const result = await this.callToolAPI(
-          resolveWaterfallToolId(provider, toolName),
-          input,
-        );
-        if (
-          result != null &&
-          typeof result === 'object' &&
-          Object.keys(result as object).length > 0
-        ) {
-          this.log(`  Found with ${provider}`);
-          return result;
-        }
-      } catch {
-        this.log(`  Failed with ${provider}`);
-      }
-    }
-
-    this.log(`  All providers exhausted`);
-    return null;
-  }
-
   private async callToolAPI(
     toolId: string,
     input: Record<string, unknown>,