deepline 0.3.284 → 0.3.286

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

@@ -160,6 +160,7 @@ import {
   attachRelayPublishedToolResultReference,
   attachToolResultListDataset,
   createToolExecuteResult,
+  projectNativeBatchToolResponse,
   parseToolExecuteResponse,
   isToolExecuteResult,
   isSerializedToolExecuteResult,
@@ -187,7 +188,6 @@ import {
   createRuntimeStepToolResultReceipts,
   createToolCallJob,
   resolveToolCallResultReceiptPolicy,
-  ToolCallReceiptLeaseLostError,
   type ToolCallReceiptCohortStore,
   type ToolCallReceiptCohortTimings,
   type ToolCallReceiptRecord,
@@ -262,26 +262,16 @@ import {
 } from './log-provenance';
 import {
   COMPLETED_RECEIPT_CACHE_INSERT_LEASE_ID,
-  DURABLE_RECEIPT_WAIT_MAX_ATTEMPTS,
   createRuntimeReceiptHydrationGate,
   runtimeStepReceiptPayloadBytes,
-  runtimeReceiptClaimLeaseIsLive,
-  runtimeReceiptWaitBudgetMs,
-  runtimeReceiptWaitDelayMs,
-  DURABLE_RECEIPT_WAIT_DELAY_MS,
-  RuntimeReceiptHydrationTurnTimeoutError,
   RuntimeReceiptLeaseLostError,
-  RuntimeReceiptWaitTimeoutError,
   executeWithDurableRuntimeReceipt,
   resolveRuntimeToolReceiptWaitMaxAttempts,
-  runtimeReceiptFailureError,
   runtimeReceiptFailureKindForError,
   runtimeReceiptOutput as durableRuntimeReceiptOutput,
   type RuntimeReceiptHydrationTurn,
   type RuntimeReceiptHydrationGateSnapshot,
   type RuntimeReceiptHydrationSource,
-  waitForCompletedRuntimeReceipt,
-  waitForCompletedRuntimeReceipts,
   type DurableReceiptExecutionStore,
 } from './durable-receipt-execution';
 import {
@@ -422,6 +412,7 @@ import type {
   ContextOptions,
   PlayCallOptions,
   PlayCheckpoint,
+  ProviderRetryCursor,
   PlayStep,
   PlayStepRowResult,
   PlayRowUpdate,
@@ -609,12 +600,6 @@ const DEEPLINE_DEVELOPER_TUNNEL_ORIGIN_502_PATTERN =
   /\bdeeplinedeveloper\.com\s*\|\s*502\s*:\s*bad gateway\b/i;
 const NODE_RUNTIME_MAP_VISIBILITY_MAX_ATTEMPTS = 100;
 const NODE_RUNTIME_MAP_VISIBILITY_RETRY_MS = 25;
-// A newly claimed receipt should normally use its scheduled heartbeat. When a
-// test/SEV policy deliberately gives it only a moment of lease life, however,
-// scheduler setup and the first provider-dispatch turn can consume that entire
-// window before the timer fires. Renew once before fan-out in that narrow case.
-// Production's normal multi-minute lease remains on the zero-extra-query path.
-const IMMEDIATE_PENDING_RECEIPT_HEARTBEAT_THRESHOLD_MS = 100;
 // Per-row sanity cap on distinct inline child invocations. `maxPlayCallDepth`
 // (governor) already bounds nesting; this bounds fan-WIDTH from one active row
 // resolver. The dedupe set is row-local, never retained for the full run.
@@ -1465,6 +1450,18 @@ function publicToolResponseEnvelope(value: unknown): {
   };
 }
 
+function nativeBatchResponseMeta(result: unknown): Record<string, unknown> {
+  return {
+    nativeBatchResponseView:
+      result &&
+      typeof result === 'object' &&
+      !Array.isArray(result) &&
+      Object.prototype.hasOwnProperty.call(result, 'data')
+        ? 'data'
+        : 'rawV2',
+  };
+}
+
 /**
  * A batched provider request returns one envelope for several logical source
  * tool calls. Each source call persists only its own item-shaped canonical
@@ -1826,7 +1823,7 @@ type ToolExecutionApiOptions = {
   completedResultCache?: boolean;
   executionAuthScopeDigest?: string | null;
   providerIdempotencyKey?: string | null;
-  /** Exact forced-member identities that participate in a native batch key. */
+  /** Invocation identities that participate in the canonical operation key. */
   providerOperationForceRefreshIdentities?: readonly string[];
   /** Presentation-only cache identity paired with a separate execution fence. */
   providerIdempotencyReceiptKey?: string | null;
@@ -1878,6 +1875,12 @@ type ToolExecutionApiOptions = {
    * cache stores only its terminal materialized output.
    */
   uncachedAsyncLifecycleCall?: boolean;
+  /** Exact outgoing delivery candidates; consume a checkpoint cursor once. */
+  legacyProviderRetryIdentities?: readonly {
+    transportReceiptKey: string;
+    providerOperationKey: string;
+    forceRefreshIdentities?: readonly string[];
+  }[];
   /**
    * Called once this call's provider response body has been fully read and
    * parsed, with that instant on the runner's clock. Measurement only: the
@@ -2594,12 +2597,6 @@ type ScalarPlayAuthoringRuntimeContext = Pick<
 export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
   private rowStates = new Map<number, RowState>();
   private toolCallQueue: ToolCallRequest[] = [];
-  private pendingRuntimeToolOwnershipAssertions: Array<{
-    targets: Array<{ receiptKey: string; leaseId: string }>;
-    resolve: () => void;
-    reject: (error: unknown) => void;
-  }> = [];
-  private runtimeToolOwnershipAssertionFlushScheduled = false;
   private runtimeToolReceiptCompletionsInFlight = new Map<string, number>();
   /**
    * The one app-side result-egress controller. It serializes receipt gateway
@@ -3225,23 +3222,14 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
         : Date.now();
     this.checkpoint.durableCallCacheEpochMs = this.durableCallCacheEpochMs;
     this.durableMappedToolResultsBackedByReceipts = Boolean(
-      (options.claimRuntimeStepReceipt || options.claimRuntimeStepReceipts) &&
       (options.getRuntimeStepReceipt || options.getRuntimeStepReceipts) &&
       (options.completeRuntimeStepReceipt ||
         options.completeRuntimeStepReceipts),
     );
-    this.durableDirectToolResultsBackedByReceipts = Boolean(
-      options.claimRuntimeStepReceipt &&
-      options.getRuntimeStepReceipt &&
-      options.completeRuntimeStepReceipt,
-    );
-    if (this.durableDirectToolResultsBackedByReceipts) {
-      // A resumed durable runner may receive a legacy checkpoint containing
-      // full tool results. Drop that redundant copy immediately and recover
-      // through the receipt store below. Bulk-only receipt contexts retain the
-      // checkpoint because direct tool calls cannot use the bulk claim path.
-      this.checkpoint.completedToolBatches = {};
-    }
+    this.durableDirectToolResultsBackedByReceipts =
+      this.durableMappedToolResultsBackedByReceipts;
+    // Existing checkpoints can be the sole completed cache from an outgoing
+    // context. Receipt-backed calls stop adding payloads, but retain old hits.
     // The governance play id keys durable ctx receipts (durableCtxKey), the
     // cycle guard, and per-parent child-call counters. It must be the STABLE
     // play name — not the per-run workflow id — so receipts written by one
@@ -4323,7 +4311,8 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
     key: string,
   ): Promise<RuntimeStepReceipt | null> {
     if (!this.#options.getRuntimeStepReceipt) {
-      return null;
+      if (!this.#options.getRuntimeStepReceipts) return null;
+      return (await this.getRuntimeStepReceipts([key])).get(key) ?? null;
     }
     const receipt = await this.#options.getRuntimeStepReceipt({ key });
     if (receipt && typeof receipt.key === 'string' && receipt.key.trim()) {
@@ -4465,7 +4454,23 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
       path: `ctx.step receipt "${key}"`,
     });
     if (!this.#options.completeRuntimeStepReceipt) {
-      return null;
+      if (!this.#options.completeRuntimeStepReceipts) return null;
+      const completed = await this.completeRuntimeStepReceipts(
+        [
+          {
+            key,
+            runId: this.currentReceiptOwnerRunId,
+            runAttempt: this.currentRunAttempt,
+            ...(leaseId ? { leaseId } : {}),
+            output,
+            ...(inlineFields ? { inlineFields } : {}),
+          },
+        ],
+        undefined,
+        undefined,
+        { retainLiveResult: true },
+      );
+      return completed.get(key) ?? null;
     }
     const completed = await this.#options.completeRuntimeStepReceipt({
       key,
@@ -4527,49 +4532,18 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
         })),
       );
       if (manifests.length === 0) return;
-      // A scalar call publishes its pointer on its own, after the canonical
-      // result has already committed, so it never rides the cohort's shared
-      // egress wave. Nothing is gained by skipping the ownership handshake
-      // here, and skipping it costs the caller a receipt row it does not own:
-      // a runtime whose claim seam refuses (or that exposes no claim seam at
-      // all) would still publish pointer rows, and an already published
-      // pointer would be rewritten on every later call. Take the row the way
-      // every other scalar receipt writer takes it, and write only what this
-      // run actually owns. The map/cohort publisher keeps the claim-free
-      // batched write, where the pointer genuinely shares the canonical
-      // result's single bounded request.
+      // The pointer is an immutable completed-cache insert, like the result
+      // it names. Publishing it needs no pending lease or read-back.
       if (
         !(
-          this.#options.claimRuntimeStepReceipt ||
-          this.#options.claimRuntimeStepReceipts
+          this.#options.completeRuntimeStepReceipt ||
+          this.#options.completeRuntimeStepReceipts
         )
       ) {
         return;
       }
-      const existing = await this.getRuntimeStepReceipts(
-        manifests.map((manifest) => manifest.key),
-        { hydrateOutput: false },
-      );
-      const missing = manifests.filter((manifest) => {
-        const receipt = existing.get(manifest.key);
-        return receipt?.status !== 'completed' && receipt?.status !== 'skipped';
-      });
-      if (missing.length === 0) return;
-      const claims = await this.claimRuntimeStepReceipts(
-        missing.map((manifest) => manifest.key),
-        sourceRunId,
-        false,
-        false,
-        false,
-        false,
-      );
-      const owned = missing.flatMap((manifest) => {
-        const leaseId = claims.get(manifest.key)?.leaseId;
-        return leaseId ? [{ ...manifest, leaseId }] : [];
-      });
-      if (owned.length === 0) return;
-      await this.completeRuntimeStepReceipts(owned, undefined, undefined, {
-        bestEffortKeys: new Set(owned.map((manifest) => manifest.key)),
+      await this.completeRuntimeStepReceipts(manifests, undefined, undefined, {
+        bestEffortKeys: new Set(manifests.map((manifest) => manifest.key)),
         onBestEffortFailure: ({ key, error }) => {
           this.runtimeLog(
             `Tool source-run receipt manifest write skipped for ${key}: ${error instanceof Error ? error.message : String(error)}`,
@@ -4789,178 +4763,6 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
     };
   }
 
-  private async assertRuntimeToolReceiptOwnership(
-    requests: ToolCallRequest[],
-  ): Promise<void> {
-    const targets = this.runtimeToolReceiptOwnershipTargets(requests);
-    if (targets.length === 0) return;
-
-    return await new Promise<void>((resolve, reject) => {
-      this.pendingRuntimeToolOwnershipAssertions.push({
-        targets,
-        resolve,
-        reject,
-      });
-      if (this.runtimeToolOwnershipAssertionFlushScheduled) return;
-      this.runtimeToolOwnershipAssertionFlushScheduled = true;
-      queueMicrotask(() => void this.flushRuntimeToolOwnershipAssertionBatch());
-    });
-  }
-
-  private runtimeToolReceiptOwnershipTargets(
-    requests: ToolCallRequest[],
-  ): Array<{ receiptKey: string; leaseId: string }> {
-    return requests.flatMap((request) => {
-      const receiptKey = request.receiptKey?.trim() || null;
-      if (!receiptKey) return [];
-      const leaseId = request.receiptLeaseId?.trim() || null;
-      if (!leaseId) return [];
-      return [{ receiptKey, leaseId }];
-    });
-  }
-
-  private async renewRuntimeToolReceiptOwnership(
-    requests: ToolCallRequest[],
-  ): Promise<void> {
-    const targets = this.runtimeToolReceiptOwnershipTargets(requests);
-    if (targets.length === 0) return;
-    if (!this.#options.heartbeatRuntimeStepReceipts) {
-      return await this.assertRuntimeToolReceiptOwnership(requests);
-    }
-    const uniqueTargets = [
-      ...new Map(targets.map((target) => [target.receiptKey, target])).values(),
-    ];
-    const receipts = await this.#options.heartbeatRuntimeStepReceipts({
-      runId: this.currentReceiptOwnerRunId,
-      runAttempt: this.currentRunAttempt,
-      keys: uniqueTargets.map((target) => target.receiptKey),
-      leaseIds: uniqueTargets.map((target) => target.leaseId),
-    });
-    this.assertRuntimeToolReceiptHeartbeatResults(uniqueTargets, receipts);
-  }
-
-  private async flushRuntimeToolOwnershipAssertionBatch(): Promise<void> {
-    this.runtimeToolOwnershipAssertionFlushScheduled = false;
-    const assertions = this.pendingRuntimeToolOwnershipAssertions.splice(0);
-    if (assertions.length === 0) return;
-    const targets = assertions.flatMap((assertion) => assertion.targets);
-
-    if (this.#options.heartbeatRuntimeStepReceipts) {
-      try {
-        const uniqueTargets = [
-          ...new Map(
-            targets.map((target) => [target.receiptKey, target]),
-          ).values(),
-        ];
-        const receipts = await this.#options.heartbeatRuntimeStepReceipts({
-          runId: this.currentReceiptOwnerRunId,
-          runAttempt: this.currentRunAttempt,
-          keys: uniqueTargets.map((target) => target.receiptKey),
-          leaseIds: uniqueTargets.map((target) => target.leaseId),
-        });
-        const renewed = new Map<string, RuntimeStepReceipt | null>();
-        for (let index = 0; index < uniqueTargets.length; index += 1) {
-          renewed.set(
-            uniqueTargets[index]!.receiptKey,
-            receipts[index] ?? null,
-          );
-        }
-        for (const assertion of assertions) {
-          const lost = assertion.targets.find((target) => {
-            const receipt = renewed.get(target.receiptKey);
-            return !this.runtimeToolReceiptStillOwned(receipt, target.leaseId);
-          });
-          if (lost) {
-            assertion.reject(
-              new RuntimeReceiptLeaseLostError({
-                receiptKey: lost.receiptKey,
-                runId: this.currentReceiptOwnerRunId,
-                leaseId: lost.leaseId,
-              }),
-            );
-          } else {
-            assertion.resolve();
-          }
-        }
-      } catch (error) {
-        for (const assertion of assertions) assertion.reject(error);
-      }
-      return;
-    }
-
-    if (
-      this.#options.getRuntimeStepReceipt ||
-      this.#options.getRuntimeStepReceipts
-    ) {
-      try {
-        const latest = await this.getRuntimeStepReceipts(
-          targets.map((target) => target.receiptKey),
-        );
-        for (const assertion of assertions) {
-          const lost = assertion.targets.find((target) => {
-            const receipt = latest.get(target.receiptKey);
-            return !this.runtimeToolReceiptStillOwned(receipt, target.leaseId);
-          });
-          if (lost) {
-            assertion.reject(
-              new RuntimeReceiptLeaseLostError({
-                receiptKey: lost.receiptKey,
-                runId: this.currentReceiptOwnerRunId,
-                leaseId: lost.leaseId,
-              }),
-            );
-          } else {
-            assertion.resolve();
-          }
-        }
-      } catch (error) {
-        for (const assertion of assertions) assertion.reject(error);
-      }
-      return;
-    }
-
-    const error = new RuntimeReceiptLeaseLostError({
-      receiptKey: targets[0]?.receiptKey ?? 'unknown',
-      runId: this.currentReceiptOwnerRunId,
-      leaseId: targets[0]?.leaseId ?? 'unknown',
-    });
-    for (const assertion of assertions) assertion.reject(error);
-  }
-
-  private assertRuntimeToolReceiptHeartbeatResults(
-    targets: Array<{ receiptKey: string; leaseId: string }>,
-    receipts: Array<RuntimeStepReceipt | null>,
-  ): void {
-    for (let index = 0; index < targets.length; index += 1) {
-      const target = targets[index]!;
-      const receipt = this.normalizeRuntimeStepReceipt(
-        target.receiptKey,
-        receipts[index],
-      );
-      if (!this.runtimeToolReceiptStillOwned(receipt, target.leaseId)) {
-        throw new RuntimeReceiptLeaseLostError({
-          receiptKey: target.receiptKey,
-          runId: this.currentReceiptOwnerRunId,
-          leaseId: target.leaseId,
-        });
-      }
-    }
-  }
-
-  private runtimeToolReceiptStillOwned(
-    receipt: RuntimeStepReceipt | null | undefined,
-    leaseId: string,
-  ): boolean {
-    if (!receipt) return false;
-    if (receipt.status === 'completed' || receipt.status === 'skipped') {
-      return true;
-    }
-    if (receipt.status !== 'running') return false;
-    if (receipt.leaseId !== leaseId) return false;
-    const ownerRunId = receipt.leaseOwnerRunId ?? receipt.runId ?? null;
-    return !ownerRunId || ownerRunId === this.currentReceiptOwnerRunId;
-  }
-
   private runtimeToolReceiptStillOwnedByCurrentAttempt(
     receipt: RuntimeStepReceipt | null | undefined,
     leaseId: string | null | undefined,
@@ -4980,18 +4782,6 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
     return ownerAttempt === this.currentRunAttempt;
   }
 
-  private isOwnedClaimedRuntimeReceipt(
-    receipt: RuntimeStepReceipt | null | undefined,
-  ): receipt is RuntimeStepReceipt {
-    return (
-      Boolean(receipt) &&
-      receipt?.claimState !== 'existing' &&
-      (receipt?.status === 'queued' ||
-        receipt?.status === 'pending' ||
-        receipt?.status === 'running')
-    );
-  }
-
   private async failRuntimeStepReceipt(
     key: string,
     _runId: string,
@@ -5359,91 +5149,6 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
     return this.normalizeRuntimeStepReceipt(input.key, receipt);
   }
 
-  private async markRuntimeStepReceiptsRunning(
-    receipts: Array<{
-      key: string;
-      runId: string;
-      leaseId?: string | null;
-    }>,
-  ): Promise<Map<string, RuntimeStepReceipt>> {
-    const normalizedInputs = receipts.filter((receipt) => receipt.key.trim());
-    if (normalizedInputs.length === 0) return new Map();
-    let marked: Array<RuntimeStepReceipt | null>;
-    const markReceipts = this.#options.markRuntimeStepReceiptsRunning;
-    if (markReceipts) {
-      marked = await this.dispatchChunkedRuntimeReceiptRequest(
-        normalizedInputs.map((receipt) => ({
-          ...receipt,
-          runId: this.currentReceiptOwnerRunId,
-          runAttempt: this.currentRunAttempt,
-        })),
-        (chunk) => markReceipts({ receipts: chunk }),
-      );
-    } else {
-      marked = await Promise.all(
-        normalizedInputs.map((receipt) =>
-          this.markRuntimeStepReceiptRunning(receipt),
-        ),
-      );
-    }
-    const byKey = new Map<string, RuntimeStepReceipt>();
-    for (let index = 0; index < marked.length; index += 1) {
-      const normalized = this.normalizeRuntimeStepReceipt(
-        normalizedInputs[index]?.key ?? '',
-        marked[index],
-      );
-      if (normalized) byKey.set(normalized.key, normalized);
-    }
-    return byKey;
-  }
-
-  private async markRuntimeStepReceiptsQueued(
-    receipts: Array<{
-      key: string;
-      runId: string;
-      leaseId?: string | null;
-    }>,
-  ): Promise<Map<string, RuntimeStepReceipt>> {
-    const normalizedInputs = receipts.filter((receipt) => receipt.key.trim());
-    if (normalizedInputs.length === 0) return new Map();
-    if (!this.#options.markRuntimeStepReceiptsQueued) {
-      return new Map();
-    }
-    const queued = await this.dispatchChunkedRuntimeReceiptRequest(
-      normalizedInputs.map((receipt) => ({
-        ...receipt,
-        runId: this.currentReceiptOwnerRunId,
-        runAttempt: this.currentRunAttempt,
-      })),
-      (chunk) =>
-        this.#options.markRuntimeStepReceiptsQueued!({ receipts: chunk }),
-    );
-    const byKey = new Map<string, RuntimeStepReceipt>();
-    for (let index = 0; index < queued.length; index += 1) {
-      const normalized = this.normalizeRuntimeStepReceipt(
-        normalizedInputs[index]?.key ?? '',
-        queued[index],
-      );
-      if (normalized) byKey.set(normalized.key, normalized);
-    }
-    return byKey;
-  }
-
-  private async parkRuntimeToolReceiptsQueued(
-    requests: ToolCallRequest[],
-  ): Promise<void> {
-    const targets = requests.flatMap((request) => {
-      const receiptKey = request.receiptKey?.trim() || null;
-      const leaseId = request.receiptLeaseId?.trim() || null;
-      if (!receiptKey || !leaseId) return [];
-      return [
-        { key: receiptKey, runId: this.currentReceiptOwnerRunId, leaseId },
-      ];
-    });
-    if (targets.length === 0) return;
-    await this.markRuntimeStepReceiptsQueued(targets);
-  }
-
   /**
    * Enforce the receipt output contract and remember the output's serialized
    * size. Idempotent per input: the first caller pays, everything downstream
@@ -6326,7 +6031,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
 
   private durableReceiptExecutionStore(): DurableReceiptExecutionStore {
     return {
-      enabled: Boolean(this.#options.claimRuntimeStepReceipt),
+      enabled: this.durableDirectToolResultsBackedByReceipts,
       get: (receiptKey) => this.getRuntimeStepReceipt(receiptKey),
       getMany: (receiptKeys) => this.getRuntimeStepReceipts(receiptKeys),
       claim: (
@@ -6403,35 +6108,6 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
     return durableRuntimeReceiptOutput<T>(receipt);
   }
 
-  private async waitForCompletedRuntimeToolReceipt(
-    key: string,
-    maxAttempts?: number,
-  ): Promise<RuntimeStepReceipt> {
-    return await waitForCompletedRuntimeReceipt({
-      receiptKey: key,
-      store: this.durableReceiptExecutionStore(),
-      maxAttempts,
-      toolErrorSchemaVersion: this.currentToolErrorSchemaVersion,
-    });
-  }
-
-  private async waitForCompletedRuntimeToolReceipts(
-    keys: string[],
-    maxAttempts?: number,
-  ): Promise<{
-    completed: Map<string, RuntimeStepReceipt>;
-    failed: Map<string, Error>;
-    timedOut: Set<string>;
-  }> {
-    return await waitForCompletedRuntimeReceipts({
-      receiptKeys: keys,
-      store: this.durableReceiptExecutionStore(),
-      maxAttempts,
-      log: (message) => this.runtimeLog(message),
-      toolErrorSchemaVersion: this.currentToolErrorSchemaVersion,
-    });
-  }
-
   private async executeWithRuntimeReceipt<T>(
     operation: DurableCtxOperation,
     id: string,
@@ -6525,7 +6201,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
         onClaimedResult: opts.onClaimedResult,
         shouldPersistFailure: opts.shouldPersistFailure,
         markRunningBeforeExecute: opts.markRunningBeforeExecute,
-        completedCacheOnly: operation === 'tool',
+        completedCacheOnly: true,
         withCompletedReceiptHydration: (hydrate) =>
           this.withRuntimeReceiptHydrationTurn(hydrate, {
             source: 'durable_operation',
@@ -6632,7 +6308,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
    *
    * The external receipt adapter is intentionally local to this migration.
    * It checks the exact compatibility identities passed by the map, while the
-   * map remains the sole writer for its member receipts, follower delivery,
+   * map remains the sole writer for its member receipts, invocation delivery,
    * and completion barrier.  In particular, do not turn an always-fresh map
    * request into a provider-idempotent request here: `apiOptions` is forwarded
    * byte-for-byte and decides whether the historical wire carried an identity.
@@ -6806,19 +6482,11 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
     });
   }
 
-  /**
-   * A forced call bypasses an earlier run's shared result, so its physical
-   * gateway invocation must bypass that result's replay identity too. Keep
-   * the transport key deterministic for one logical call: a retry of that
-   * call still converges, while a later explicit force gets a fresh identity.
-   */
+  /** One replay-stable physical delivery identity for each invocation. */
   private toolTransportReceiptKey(input: {
     toolId: string;
-    resultReceiptKey: string;
     providerOperationKey: string;
-    force?: boolean;
   }): string {
-    if (input.force !== true) return input.resultReceiptKey;
     return `${buildDurableToolReceiptPrefix({
       orgId: this.#options.orgId,
       toolId: input.toolId,
@@ -6841,41 +6509,20 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
     });
   }
 
-  /**
-   * Ordinary operations do not carry provider-idempotency metadata, but the
-   * execution relay still needs a semantic signal that an explicit force is
-   * a new provider operation. Unsafe-write operations already carry their
-   * forced provider key directly, so only ordinary calls need this attested
-   * canonical-operation salt.
-   */
-  private providerForceRefreshIdentitiesForToolCall(input: {
+  /** Keep independent misses distinct in the gateway's canonical operation. */
+  private providerInvocationOptionsForToolCall(input: {
     operationKey: string;
-    force?: boolean;
     requiresExecutionFence?: boolean;
     logicalCallId?: string;
-  }): string[] {
-    if (input.force !== true || input.requiresExecutionFence === true) {
-      return [];
-    }
-    return [
-      this.providerIdempotencyKeyForToolCall({
-        operationKey: input.operationKey,
-        force: true,
-        logicalCallId: input.logicalCallId,
-      }),
-    ];
-  }
-
-  private providerForceRefreshOptionsForToolCall(input: {
-    operationKey: string;
     force?: boolean;
-    requiresExecutionFence?: boolean;
-    logicalCallId?: string;
   }): Pick<ToolExecutionApiOptions, 'providerOperationForceRefreshIdentities'> {
-    const identities = this.providerForceRefreshIdentitiesForToolCall(input);
-    return identities.length > 0
-      ? { providerOperationForceRefreshIdentities: identities }
-      : {};
+    return input.requiresExecutionFence === true
+      ? {}
+      : {
+          providerOperationForceRefreshIdentities: [
+            this.providerInvocationKeyForToolCall(input),
+          ],
+        };
   }
 
   /**
@@ -7577,15 +7224,10 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
   private getCachedToolResult(
     toolId: string,
     rowCacheKey: string,
-    path: 'mapped' | 'direct' = 'mapped',
+    _path: 'mapped' | 'direct' = 'mapped',
   ): ToolBatchResult | undefined {
-    if (
-      path === 'direct'
-        ? this.durableDirectToolResultsBackedByReceipts
-        : this.durableMappedToolResultsBackedByReceipts
-    ) {
-      return undefined;
-    }
+    // Receipt-backed calls never add payloads here. Retained outgoing entries
+    // may predate that capability and remain completed cache hits.
     return this.checkpoint.completedToolBatches[toolId]?.[rowCacheKey];
   }
 
@@ -7636,32 +7278,12 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
     if (!this.checkpoint.completedToolBatches[toolId]) {
       this.checkpoint.completedToolBatches[toolId] = {};
     }
-    this.checkpoint.completedToolBatches[toolId]![rowCacheKey] = {
+    this.checkpoint.completedToolBatches[toolId]![rowCacheKey] ??= {
       done: true,
       result,
     };
   }
 
-  private buildToolResultCacheKey(input: {
-    rowId: number;
-    tableNamespace?: string;
-    rowKey?: string;
-    callId?: string;
-  }): string {
-    const scope =
-      this.currentGovernance.currentRunId || this.#options.runId || 'run';
-    if (input.callId?.trim()) {
-      return `${scope}:${input.callId.trim()}`;
-    }
-    if (input.rowKey?.trim()) {
-      return `${scope}:${input.rowKey.trim()}`;
-    }
-    if (input.tableNamespace?.trim()) {
-      return `${scope}:${input.tableNamespace.trim()}:${input.rowId}`;
-    }
-    return `${scope}:direct:${input.rowId}`;
-  }
-
   private async resolveToolResultMetadata(
     toolId: string,
   ): Promise<ToolResultMetadataInput> {
@@ -7753,6 +7375,10 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
   private materializeToolExecutionResult(
     result: ToolExecuteResult,
   ): ToolExecuteResult {
+    result = projectNativeBatchToolResponse(
+      result,
+      this.currentRuntimeContract.semantics.tools.nativeBatchResponse,
+    );
     if (
       this.currentToolResponseContract === RAW_V2_TOOL_RESPONSE_CONTRACT ||
       !this.hasPinnedToolResponseContract ||
@@ -8136,40 +7762,13 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
         `Durable tool call ${receiptKey} completed live after its receipt lease moved; using live result without overwriting the receipt.`,
       );
     }
-    const finalWrapped =
-      (completed?.status === 'completed' || completed?.status === 'skipped') &&
-      completed.output !== undefined
-        ? await this.wrapToolExecutionResult({
-            toolId,
-            status:
-              completed.output === null || completed.output === undefined
-                ? 'no_result'
-                : 'completed',
-            result: this.runtimeReceiptOutput(completed),
-            requestInput: request.input,
-            execution: toolExecutionMetadataForOutcome(
-              completed.runId === this.currentReceiptOwnerRunId
-                ? {
-                    kind: 'live',
-                    cacheKey,
-                    receiptKey: request.receiptKey,
-                  }
-                : {
-                    kind: 'cache',
-                    cacheKey,
-                    receiptKey: receiptKey ?? '',
-                    attachedToReceiptKey: receiptKey,
-                  },
-            ),
-          })
-        : wrapped;
     if (request.cacheable !== false) {
-      this.cacheToolResult(toolId, cacheKey, finalWrapped);
+      this.cacheToolResult(toolId, cacheKey, wrapped);
     }
 
     const resolver = this.toolCallResolvers.get(request.callId);
     if (resolver) {
-      resolver.resolve(finalWrapped);
+      resolver.resolve(wrapped);
       this.toolCallResolvers.delete(request.callId);
     }
 
@@ -8185,7 +7784,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
       error: null,
       dataPatch: {},
     });
-    return finalWrapped;
+    return wrapped;
   }
 
   private async rejectToolCall(
@@ -9003,6 +8602,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
                 Math.max(0, failedCount - staleFailedKeys.size),
               progressSupersededOffset: () =>
                 staleCompletedKeys.size + staleFailedKeys.size,
+              progressSkippedOffset: () => duplicateReuseCount,
               progressTotalRows: () => totalInputCount,
               rowFeed: execution.rowFeed,
               retainedRowsMemoryBudgetBytes:
@@ -10231,6 +9831,8 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
       progressCompletedOffset?: number | (() => number);
       progressFailedOffset?: number | (() => number);
       progressSupersededOffset?: number | (() => number);
+      /** Input duplicates discovered after admission; excludes resolver outcomes. */
+      progressSkippedOffset?: number | (() => number);
       progressTotalRows?: number | (() => number);
       /**
        * When set, `items`, `executionRowKeys` and `executionRowIndexes` grow
@@ -10476,6 +10078,37 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
     } | null = null;
     let lastFrameFlushAt = 0;
     let rowsSinceFrameFlush = 0;
+    // Scalars only: resolver admission is visible before the first row's
+    // durable completion, without publishing one event per row or tool call.
+    let startedResolverRows = 0;
+    let activeResolverRows = 0;
+    let tracksResolverActivity = false;
+    // Persistence can move current resolvers between successful, failed and
+    // superseded offsets. They already contribute to startedResolverRows:
+    // only the settled baseline before this pool started belongs in admission.
+    const initiallyStartedRows =
+      liveNumber(runtimeOptions?.progressCompletedOffset, completedRows) +
+      liveNumber(runtimeOptions?.progressFailedOffset, 0) +
+      liveNumber(runtimeOptions?.progressSupersededOffset, 0);
+    const initiallySkippedRows = liveNumber(
+      runtimeOptions?.progressSkippedOffset,
+      0,
+    );
+    const mapActivityCounts = () => {
+      const startedRows =
+        initiallyStartedRows +
+        (liveNumber(
+          runtimeOptions?.progressSkippedOffset,
+          initiallySkippedRows,
+        ) -
+          initiallySkippedRows) +
+        startedResolverRows;
+      return {
+        startedRows,
+        activeRows: activeResolverRows,
+        waitingRows: currentTotalRows() - startedRows,
+      };
+    };
     const updateMapFrameProgress = (input: {
       status?: MapExecutionFrame['status'];
       completedRowKey?: string | null;
@@ -10607,6 +10240,9 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
             completedRowKeys.size,
           failedRows,
           totalRows: currentTotalRows(),
+          ...(progressEventType === 'map.progress' && tracksResolverActivity
+            ? mapActivityCounts()
+            : {}),
           supersededRows: liveNumber(
             runtimeOptions?.progressSupersededOffset,
             existing.supersededRows ?? 0,
@@ -11254,6 +10890,39 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
             items[idx] = null as unknown as T;
           }
         : null;
+    let lastMapActivityKey: string | null = null;
+    tracksResolverActivity = true;
+    const publishMapActivity = () => {
+      const counts = mapActivityCounts();
+      const key = `${counts.startedRows}:${counts.activeRows}:${counts.waitingRows}`;
+      if (key === lastMapActivityKey) return;
+      lastMapActivityKey = key;
+      // Admission samples do not rebuild checkpoint key sets. The map's
+      // writer continues to own durable settlement and checkpoint flushing.
+      this.emitExecutionEvent({
+        type: 'map.progress',
+        mapInvocationId: mapScope.mapInvocationId,
+        mapNodeId: mapScope.mapNodeId ?? null,
+        logicalNamespace: mapScope.logicalNamespace,
+        artifactTableNamespace: mapScope.artifactTableNamespace,
+        completedRows:
+          liveNumber(runtimeOptions?.progressCompletedOffset, completedRows) +
+          (liveFrameSets?.completedRowKeys.size ?? 0),
+        failedRows:
+          liveNumber(runtimeOptions?.progressFailedOffset, 0) +
+          (liveFrameSets?.failedRowsCount ?? 0),
+        totalRows: currentTotalRows(),
+        supersededRows: liveNumber(runtimeOptions?.progressSupersededOffset, 0),
+        ...counts,
+        ...this.inlineChildAggregateEventFields(),
+        at: Date.now(),
+      });
+    };
+    const mapActivityTimer = setInterval(
+      publishMapActivity,
+      PROGRESS_HEARTBEAT_INTERVAL_MS,
+    );
+    mapActivityTimer.unref();
     const workers = Array.from({ length: workerCount }, async () => {
       while (firstRowError == null) {
         if (nextRowIndex >= items.length) {
@@ -11270,7 +10939,13 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
           releaseDispatchedInputRow?.(idx);
           settledResults[idx] = await mapRowFlow.run({ baseRow }, async () => {
             this.assertRowAdmissionOpen();
-            return await runRow(idx, baseRow);
+            startedResolverRows += 1;
+            activeResolverRows += 1;
+            try {
+              return await runRow(idx, baseRow);
+            } finally {
+              activeResolverRows -= 1;
+            }
           });
         } catch (error) {
           // RuntimeFlow has already returned the row slot and memory lease.
@@ -11364,6 +11039,8 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
         settled = await Promise.allSettled(workers);
       }
     } finally {
+      clearInterval(mapActivityTimer);
+      publishMapActivity();
       datasetStep.items = currentTotalRows();
       this.processedRowCount = currentTotalRows();
       mapStallObserver?.stopHeartbeat();
@@ -12930,7 +12607,6 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
         options.receiptWaitMs,
       );
     }
-    const executionScope = this.currentExecutionScope;
     const normalizedKey = this.normalizeContextKey(key, 'tool');
     const toolCachePolicy = this.effectiveToolCallCachePolicy(options);
     const toolRequestIdentity = deriveToolRequestIdentity({
@@ -13028,10 +12704,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
       ...(legacyDurableCacheKey ? [legacyDurableCacheKey] : []),
     ];
 
-    const executeTool = async (context?: {
-      leaseId?: string | null;
-      retainExternalCallSlot?: (release: () => void) => void;
-    }): Promise<unknown> => {
+    const executeTool = async (): Promise<unknown> => {
       if (eventWaitHandler) {
         return this.executeIntegrationEventWaitTool(
           toolId,
@@ -13291,7 +12964,6 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
           });
         };
         try {
-          const directReceiptLeaseId = context?.leaseId?.trim() || null;
           if (!logicalCallId) {
             throw new Error(
               'Direct tool execution requires a stable logical call identity.',
@@ -13299,17 +12971,15 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
           }
           const useDirectResultReceipts =
             cacheableToolResult && !bypassDirectResultCache;
-          const providerOperationKey = this.providerIdempotencyKeyForToolCall({
+          const providerOperationKey = this.providerInvocationKeyForToolCall({
             operationKey: providerIdempotencyKeyBase,
-            force: cacheableToolResult && toolCachePolicy.force,
             logicalCallId,
+            force: toolCachePolicy.force,
           });
           const physicalDirectKey = useDirectResultReceipts
             ? this.toolTransportReceiptKey({
                 toolId,
-                resultReceiptKey: directCacheKey,
                 providerOperationKey,
-                force: toolCachePolicy.force,
               })
             : `${buildDurableToolReceiptPrefix({
                 orgId: this.#options.orgId ?? 'unknown-org',
@@ -13323,13 +12993,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
             runId: this.currentRunId,
             logicalCallId,
             force: toolCachePolicy.force,
-            canStoreResult: Boolean(
-              this.#options.claimRuntimeStepReceipt &&
-              (this.#options.getRuntimeStepReceipt ||
-                this.#options.getRuntimeStepReceipts) &&
-              (this.#options.completeRuntimeStepReceipt ||
-                this.#options.completeRuntimeStepReceipts),
-            ),
+            canStoreResult: this.durableDirectToolResultsBackedByReceipts,
           });
           const toolRetryPolicy = await this.#options
             .getToolRetryPolicy?.(toolId, input)
@@ -13365,28 +13029,17 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
                   ...(useDirectResultReceipts
                     ? {
                         durableCallReceiptKey: physicalDirectKey,
+                        legacyProviderRetryIdentities: toolCachePolicy.force
+                          ? undefined
+                          : [
+                              {
+                                transportReceiptKey: directCacheKey,
+                                providerOperationKey:
+                                  providerIdempotencyKeyBase,
+                              },
+                            ],
                         completedResultCache: true,
                         executionAuthScopeDigest,
-                        ...(directReceiptLeaseId &&
-                        (this.#options.heartbeatRuntimeStepReceipts ||
-                          this.#options.getRuntimeStepReceipt ||
-                          this.#options.getRuntimeStepReceipts)
-                          ? {
-                              beforeProviderCall: async () => {
-                                await this.assertRuntimeToolReceiptOwnership([
-                                  {
-                                    callId: 'direct',
-                                    cacheKey: directCacheKey,
-                                    receiptKey: directCacheKey,
-                                    receiptLeaseId: directReceiptLeaseId,
-                                    rowId: -1,
-                                    toolId,
-                                    input,
-                                  },
-                                ]);
-                              },
-                            }
-                          : {}),
                       }
                     : {}),
                   ...(toolRetryPolicy?.requiresExecutionFence === true
@@ -13401,15 +13054,13 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
                             : physicalDirectKey,
                       }
                     : {}),
-                  ...(useDirectResultReceipts && operationKey
-                    ? this.providerForceRefreshOptionsForToolCall({
-                        operationKey: providerIdempotencyKeyBase,
-                        force: toolCachePolicy.force,
-                        requiresExecutionFence:
-                          toolRetryPolicy?.requiresExecutionFence,
-                        logicalCallId,
-                      })
-                    : {}),
+                  ...this.providerInvocationOptionsForToolCall({
+                    operationKey: providerIdempotencyKeyBase,
+                    requiresExecutionFence:
+                      toolRetryPolicy?.requiresExecutionFence,
+                    logicalCallId,
+                    force: toolCachePolicy.force,
+                  }),
                   playNodeScope: buildPlayNodeScope({
                     toolId,
                     callKey: normalizedKey,
@@ -13419,7 +13070,6 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
                     options?.timeoutMs,
                     this.currentAuthoringContractEdition,
                   ),
-                  retainToolSlot: context?.retainExternalCallSlot,
                 },
               });
               return await this.wrapToolExecutionResult({
@@ -13558,20 +13208,9 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
 
       const rowId = store.rowId;
       const fieldName = store.fieldName;
-      const callId = [
-        executionScope.receipt.namespace,
-        store.tableNamespace?.trim() || 'map',
-        store.rowKey?.trim() || String(rowId),
-        normalizedKey,
-        toolId,
-        toolRequestIdentity,
-      ].join(':');
-      if (this.toolCallResolvers.has(callId)) {
-        throw new Error(
-          `ctx.tools.execute("${normalizedKey}") was called more than once concurrently for the same row. ` +
-            'Use a unique id for each row-scoped tool call.',
-        );
-      }
+      // Cache identity is shared by matching completed results. Delivery
+      // identity belongs to this invocation, even when callers reuse an id.
+      const callId = logicalCallId;
 
       const toolResultCacheKey = durableCacheKey;
       const cached = !cacheableToolResult
@@ -13597,7 +13236,6 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
       const rowToolRetryPolicy = await this.#options
         .getToolRetryPolicy?.(toolId, input)
         .catch(() => null);
-
       // ADR 0018: record this leg before it runs. `producer` still names the
       // last leg (the usual cascade winner); `producers` keeps every leg, which
       // is the only durable record a losing leg ever gets — a failed tool call
@@ -13641,7 +13279,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
       // The tail of that wall. The dispatcher stamps the request when this
       // call's provider body finished parsing; the difference here is what
       // receipt completion and hand-back cost after the provider was done. A
-      // cache hit and a follower never read a body, so they leave no stamp and
+      // cache hit never reads a body, so it leaves no stamp and
       // record nothing rather than a delivery of zero.
       const observeResultDelivery = () => {
         const bodyCompletedAtMs = dispatchRequest.providerBodyCompletedAtMs;
@@ -15389,7 +15027,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
    *
    * Gated on the same stamp `resultDelivery` is gated on — a body this request
    * really read — so every delivery sub-phase counts the same calls and their
-   * sum can be checked against the whole. A cache hit, a follower, and a
+   * sum can be checked against the whole. A cache hit and a
    * member that never reached the provider leave the stamp unset and record
    * nothing rather than a wrap of zero.
    */
@@ -15521,179 +15159,38 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
 
   // ——— Batched tool call execution ———
 
-  private startPendingToolReceiptHeartbeat(
-    requests: ToolCallRequest[],
-    claimsEstablishedExecutionFence: boolean,
-  ): {
-    stop: () => void;
-    leaseLost: () => unknown | null;
-    confirmOwned: () => Promise<void>;
-    assertOwned: () => void;
-  } | null {
-    const heartbeatReceipts = this.#options.heartbeatRuntimeStepReceipts;
-    const ownedRequests = requests.filter(
-      (request) => request.receiptKey && request.receiptLeaseId,
-    );
-    if (!heartbeatReceipts || ownedRequests.length === 0) return null;
-
-    const earliestLeaseExpiry = ownedRequests.reduce<string | null>(
-      (earliest, request) => {
-        const expiresAt = request.receiptLeaseExpiresAt ?? null;
-        if (!expiresAt) return earliest;
-        if (!earliest) return expiresAt;
-        return Date.parse(expiresAt) < Date.parse(earliest)
-          ? expiresAt
-          : earliest;
-      },
-      null,
-    );
-    let leaseLost: unknown | null = null;
-    let ownershipConfirmedUntilMs = Number.isFinite(
-      Date.parse(earliestLeaseExpiry ?? ''),
-    )
-      ? Date.parse(earliestLeaseExpiry!)
-      : Date.now() + PLAY_RUNTIME_WORK_RECEIPT_LEASE_TTL_MS;
-    const firstOwnedRequest = ownedRequests[0]!;
-    const heartbeatOwnedRequests = async () => {
-      // Receipt claims are acquired in bulk before the provider-shaped
-      // dispatcher admits every call. Renew the undispatched tail as well as
-      // in-flight calls; otherwise a slow provider can let later claims
-      // expire while they are still waiting behind the concurrency gate.
-      const unsettled = ownedRequests.filter((request) =>
-        this.toolCallResolvers.has(request.callId),
-      );
-      if (unsettled.length === 0) return 'terminal' as const;
-      const byReceiptKey = new Map<string, ToolCallRequest[]>();
-      for (const request of unsettled) {
-        const receiptKey = request.receiptKey!;
-        const group = byReceiptKey.get(receiptKey) ?? [];
-        group.push(request);
-        byReceiptKey.set(receiptKey, group);
+  /**
+   * Concrete RuntimeStepReceipt adapter for the map receipt-cohort Module.
+   *
+   * Scalar and provider-native map calls share completed-result cache reads
+   * and atomic successful inserts. A miss has no durable execution owner.
+   */
+  private createRuntimeStepToolCallReceiptCohortStore(input: {
+    toolId: string;
+    requestForReceipt: ReadonlyMap<string, ToolCallRequest>;
+    /** Each invocation sharing a completed-result key, for manifests and timing. */
+    requestsForReceipt: ReadonlyMap<string, readonly ToolCallRequest[]>;
+  }): ToolCallReceiptCohortStore {
+    const requestsForPublication = (receipt: {
+      resultReceiptKey: string;
+      memberIds?: readonly string[];
+    }): readonly ToolCallRequest[] => {
+      if (!receipt.memberIds) {
+        const request = input.requestForReceipt.get(receipt.resultReceiptKey);
+        return request ? [request] : [];
       }
-      // One content-addressed receipt can have many same-run followers. The
-      // store renews unique receipt rows, not request positions, so dedupe by
-      // key while preserving the matching per-row lease id.
-      const entries = [...byReceiptKey];
-      const keys = entries.map(([receiptKey]) => receiptKey);
-      const leaseIds = entries.map(
-        ([, requests]) => requests[0]!.receiptLeaseId!,
-      );
-      const receipts = await heartbeatReceipts({
-        runId: this.currentReceiptOwnerRunId,
-        runAttempt: this.currentRunAttempt,
-        keys,
-        leaseIds,
-      });
-      const renewedExpiries: number[] = [];
-      for (let index = 0; index < entries.length; index += 1) {
-        const [receiptKey, requests] = entries[index]!;
-        const leaseId = leaseIds[index]!;
-        // Completion can race this bulk heartbeat response. A settled
-        // receipt group no longer needs ownership and must not turn that
-        // race into a false lease-loss failure or hold the confirmation
-        // horizon at its old expiry.
-        if (
-          this.runtimeToolReceiptCompletionsInFlight.has(receiptKey) ||
-          !requests.some((request) =>
-            this.toolCallResolvers.has(request.callId),
-          )
-        ) {
-          continue;
-        }
-        const receipt = receipts[index] ?? null;
-        const renewedExpiryMs = Date.parse(receipt?.leaseExpiresAt ?? '');
-        if (
-          !this.runtimeToolReceiptStillOwned(receipt, leaseId) ||
-          !Number.isFinite(renewedExpiryMs)
-        ) {
-          throw new RuntimeReceiptLeaseLostError({
-            receiptKey,
-            runId: this.currentReceiptOwnerRunId,
-            leaseId,
-          });
-        }
-        renewedExpiries.push(renewedExpiryMs);
-      }
-      if (renewedExpiries.length === 0) return 'terminal' as const;
-      ownershipConfirmedUntilMs = Math.min(...renewedExpiries);
-      return 'active' as const;
-    };
-    const perCallHeartbeatIntervalMs = runtimeLeaseHeartbeatIntervalFromExpiry({
-      leaseExpiresAt: earliestLeaseExpiry,
-      fallbackTtlMs: PLAY_RUNTIME_WORK_RECEIPT_LEASE_TTL_MS,
-    });
-    const supervisor = createRuntimeReceiptHeartbeatSupervisor({
-      // The cohort owns claims that have not reached provider admission yet.
-      // Renew it before the one-call supervisors can win the same short-lease
-      // timer race, so the queued tail remains fenced while the active call
-      // consumes the provider concurrency slot.
-      intervalMs: Math.max(1, Math.floor(perCallHeartbeatIntervalMs / 2)),
-      heartbeat: heartbeatOwnedRequests,
-      isLeaseLost: (error) => error instanceof RuntimeReceiptLeaseLostError,
-      onLeaseLost: (error) => {
-        leaseLost ??= error;
-      },
-      onTransientFailure: (error) => {
-        this.runtimeLog(
-          `Pending tool receipt heartbeat transport failed; retrying: ${error instanceof Error ? error.message : String(error)}`,
+      const requests =
+        input.requestsForReceipt.get(receipt.resultReceiptKey) ?? [];
+      return receipt.memberIds.map((memberId) => {
+        const request = requests.find(
+          (candidate) => candidate.callId === memberId,
         );
-      },
-    });
-    return {
-      stop: () => supervisor.stop(),
-      leaseLost: () => leaseLost,
-      confirmOwned: async () => {
-        // The scheduler receipt gateway returns `running` from an atomic
-        // claim. That claim is already the provider-execution fence, so short
-        // calls only need scheduled renewal if they approach lease expiry.
-        // Other callers may still return queued/pending claims or omit the
-        // explicit backend capability; retain the immediate ownership check
-        // for those receipts.
-        if (claimsEstablishedExecutionFence) {
-          if (
-            ownershipConfirmedUntilMs - Date.now() <=
-            IMMEDIATE_PENDING_RECEIPT_HEARTBEAT_THRESHOLD_MS
-          ) {
-            const outcome = await heartbeatOwnedRequests();
-            if (outcome === 'active') supervisor.start();
-            return;
-          }
-          supervisor.start();
-          return;
+        if (!request) {
+          throw new Error(`Unknown Tool Call publication member ${memberId}.`);
         }
-        const outcome = await heartbeatOwnedRequests();
-        if (outcome === 'active') supervisor.start();
-      },
-      assertOwned: () => {
-        if (leaseLost) throw leaseLost;
-        if (Date.now() < ownershipConfirmedUntilMs) return;
-        throw new RuntimeReceiptLeaseLostError({
-          receiptKey: firstOwnedRequest.receiptKey!,
-          runId: this.currentReceiptOwnerRunId,
-          leaseId: firstOwnedRequest.receiptLeaseId!,
-        });
-      },
+        return request;
+      });
     };
-  }
-
-  /**
-   * Concrete RuntimeStepReceipt adapter for the map receipt-cohort Module.
-   *
-   * Scalar and provider-native map calls share completed-result cache reads
-   * and atomic successful inserts. A miss has no durable execution owner.
-   */
-  private createRuntimeStepToolCallReceiptCohortStore(input: {
-    toolId: string;
-    requestForReceipt: ReadonlyMap<string, ToolCallRequest>;
-    /**
-     * Every request sharing a receipt key, for delivery timing only. Two rows
-     * asking the same question share one key, and only one of them — the
-     * cohort's owner — executed and carries the wrap stamp `deliveryPublishWait`
-     * is measured from, so the timing lookup cannot use the single-request map
-     * above, which keeps whichever request was seen last.
-     */
-    requestsForReceipt: ReadonlyMap<string, readonly ToolCallRequest[]>;
-  }): ToolCallReceiptCohortStore {
     const asRecord = async (
       resultReceiptKey: string,
       storedReceiptKey: string,
@@ -15879,23 +15376,15 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
           );
           const manifestCompletions =
             this.sourceRunToolReceiptManifestCompletionInputs(
-              receipts.flatMap((receipt) => {
-                const request = input.requestForReceipt.get(
-                  receipt.resultReceiptKey,
-                );
-                return request
-                  ? [
-                      {
-                        toolId: input.toolId,
-                        logicalCallId: request.logicalCallId,
-                        executionAuthScopeDigest:
-                          request.executionAuthScopeDigest,
-                        resultReceiptKey: receipt.resultReceiptKey,
-                        providerActionVersion: request.providerActionVersion,
-                      },
-                    ]
-                  : [];
-              }),
+              receipts.flatMap((receipt) =>
+                requestsForPublication(receipt).map((request) => ({
+                  toolId: input.toolId,
+                  logicalCallId: request.logicalCallId,
+                  executionAuthScopeDigest: request.executionAuthScopeDigest,
+                  resultReceiptKey: receipt.resultReceiptKey,
+                  providerActionVersion: request.providerActionVersion,
+                })),
+              ),
             );
           await this.completeRuntimeStepReceipts(
             [...canonicalCompletions, ...manifestCompletions],
@@ -15905,18 +15394,16 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
             // charged to one of the two rather than to neither.
             (enqueuedAtMs) => {
               for (const receipt of receipts) {
-                const wrappedAtMs = (
-                  input.requestsForReceipt.get(receipt.resultReceiptKey) ?? []
-                ).find(
-                  (request) => request.deliveryWrappedAtMs != null,
-                )?.deliveryWrappedAtMs;
-                if (wrappedAtMs == null) continue;
-                this.resourceGovernor.observe({
-                  deliveryPublishWaitMs: Math.max(
-                    0,
-                    enqueuedAtMs - wrappedAtMs,
-                  ),
-                });
+                for (const request of requestsForPublication(receipt)) {
+                  const wrappedAtMs = request.deliveryWrappedAtMs;
+                  if (wrappedAtMs == null) continue;
+                  this.resourceGovernor.observe({
+                    deliveryPublishWaitMs: Math.max(
+                      0,
+                      enqueuedAtMs - wrappedAtMs,
+                    ),
+                  });
+                }
               }
             },
             // The completion writer batches by arrival, so a publication wave
@@ -16011,57 +15498,6 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
             : request.input,
         ),
       })),
-      // Claim immediately so unrelated owned rows can cross provider work
-      // while foreign members hydrate in the bounded lane.
-      eager: true,
-    });
-
-    // Claims carry their actual expiry. Seed the cohort supervisor from that
-    // lease rather than the generic fallback, otherwise a long provider-shaped
-    // queue can let undispatched rows expire before its first renewal.
-    for (const request of requests) {
-      const member = cohort.member(request.callId);
-      if (member.kind !== 'owned') continue;
-      request.receiptLeaseId = member.lease.leaseId;
-      request.receiptLeaseExpiresAt = member.leaseExpiresAt ?? null;
-    }
-
-    const earliestLeaseExpiry = requests.reduce<string | null>(
-      (earliest, request) => {
-        const expiresAt = request.receiptLeaseExpiresAt ?? null;
-        if (!expiresAt) return earliest;
-        if (!earliest) return expiresAt;
-        return Date.parse(expiresAt) < Date.parse(earliest)
-          ? expiresAt
-          : earliest;
-      },
-      null,
-    );
-    // One cohort-wide liveness check closes the claim-to-provider window; the
-    // per-call views additionally preserve the historical exact admission
-    // fence immediately before an individual provider request.
-    await cohort.heartbeat();
-    let cohortLeaseLost: unknown | null = null;
-    const heartbeat = cohort.startHeartbeat({
-      intervalMs: Math.max(
-        1,
-        Math.floor(
-          runtimeLeaseHeartbeatIntervalFromExpiry({
-            leaseExpiresAt: earliestLeaseExpiry,
-            fallbackTtlMs: PLAY_RUNTIME_WORK_RECEIPT_LEASE_TTL_MS,
-          }) / 2,
-        ),
-      ),
-      onLeaseLost: (error) => {
-        cohortLeaseLost ??= error;
-      },
-      onTransientFailure: (error) => {
-        this.runtimeLog(
-          `Tool Call Receipt Cohort heartbeat transport failed; retrying: ${
-            error instanceof Error ? error.message : String(error)
-          }`,
-        );
-      },
     });
 
     const successful: ToolCallRequest[] = [];
@@ -16108,35 +15544,23 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
       });
     };
 
-    const handled = new Set<string>();
-    const followerResults: Promise<void>[] = [];
-    const collectReadyMembers = (): Array<{
+    const cachedResults: Promise<void>[] = [];
+    const owned: Array<{
       request: ToolCallRequest;
       receipts: ToolResultReceipts;
-    }> => {
-      const owned: Array<{
-        request: ToolCallRequest;
-        receipts: ToolResultReceipts;
-      }> = [];
-      for (const request of requests) {
-        if (handled.has(request.callId)) continue;
-        const member = cohort.member(request.callId);
-        handled.add(request.callId);
-        if (member.kind === 'completed') {
-          followerResults.push(resolve(request, member.result, member.source));
-        } else if (member.kind === 'following') {
-          followerResults.push(
-            member.result.then(
-              async (result) => await resolve(request, result, 'owner'),
-              async (error: unknown) => await reject(request, error),
-            ),
-          );
-        } else {
-          owned.push({ request, receipts: member.receipts });
-        }
+    }> = [];
+    for (const request of requests) {
+      const member = cohort.member(request.callId);
+      if (member.kind === 'completed') {
+        cachedResults.push(resolve(request, member.result, member.source));
+      } else if (member.kind === 'owned') {
+        owned.push({ request, receipts: member.receipts });
+      } else {
+        throw new Error(
+          'A completed-result cache cannot own a pending invocation.',
+        );
       }
-      return owned;
-    };
+    }
 
     const width = Math.min(
       this.governor.policy.concurrency.toolCalls,
@@ -16148,85 +15572,91 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
         ),
       ),
     );
-    const dispatchOwned = async (
-      owned: Array<{
-        request: ToolCallRequest;
-        receipts: ToolResultReceipts;
-      }>,
-    ) =>
-      await dispatchBoundedSettled(
-        owned,
-        width,
-        async ({ request, receipts }) => {
-          // Circuit breaker: do not dispatch this provider call once a
-          // persistence failure has occurred in this run. Rejected through the
-          // same path as a provider failure — `dispatchBoundedSettled` only
-          // collects a thrown error, so throwing past `reject` here would
-          // leave this row's tool-call resolver pending for the life of the
-          // map.
-          if (this.persistenceLatch.tripped) {
-            this.persistenceLatch.preventedCallCount += 1;
-            await reject(
-              request,
-              new RuntimePersistenceCircuitOpenError(this.persistenceLatch),
-            );
-            return;
-          }
-          let releaseToolSlot: () => void = () => undefined;
-          try {
-            const providerOperationKey = this.providerIdempotencyKeyForToolCall(
-              {
+    await dispatchBoundedSettled(
+      owned,
+      width,
+      async ({ request, receipts }) => {
+        // Circuit breaker: do not dispatch this provider call once a
+        // persistence failure has occurred in this run. Rejected through the
+        // same path as a provider failure — `dispatchBoundedSettled` only
+        // collects a thrown error, so throwing past `reject` here would
+        // leave this row's tool-call resolver pending for the life of the
+        // map.
+        if (this.persistenceLatch.tripped) {
+          this.persistenceLatch.preventedCallCount += 1;
+          await reject(
+            request,
+            new RuntimePersistenceCircuitOpenError(this.persistenceLatch),
+          );
+          return;
+        }
+        let releaseToolSlot: () => void = () => undefined;
+        try {
+          const providerOperationKey = this.providerInvocationKeyForToolCall({
+            operationKey:
+              request.providerIdempotencyKeyBase ?? request.receiptKey!,
+            logicalCallId: request.logicalCallId,
+            force: request.force,
+          });
+          const result = await this.executeMappedToolCallThroughModule({
+            request,
+            dispatchToolId: toolId,
+            dispatchPayload: request.input,
+            resultReceiptKey:
+              this.mappedToolResultReceiptPolicy(request).resultReceiptKey,
+            providerOperationKey,
+            resultReceipts: receipts,
+            apiOptions: {
+              playNodeScope: playNodeScopeForToolCallRequest(request),
+              durableCallReceiptKey: this.toolTransportReceiptKey({
+                toolId,
+                providerOperationKey,
+              }),
+              legacyProviderRetryIdentities: [
+                {
+                  transportReceiptKey: request.receiptKey!,
+                  providerOperationKey: request.force
+                    ? providerOperationKey
+                    : this.providerOperationKeyForQueuedToolCall(request),
+                  ...(request.force && request.requiresExecutionFence !== true
+                    ? { forceRefreshIdentities: [providerOperationKey] }
+                    : {}),
+                },
+              ],
+              completedResultCache: true,
+              executionAuthScopeDigest: request.executionAuthScopeDigest,
+              ...(request.requiresExecutionFence === true
+                ? {
+                    providerIdempotencyKey: providerOperationKey,
+                    providerIdempotencyReceiptKey: request.receiptKey,
+                  }
+                : {}),
+              ...this.providerInvocationOptionsForToolCall({
                 operationKey:
                   request.providerIdempotencyKeyBase ?? request.receiptKey!,
-                force: request.force === true,
+                requiresExecutionFence: request.requiresExecutionFence,
                 logicalCallId: request.logicalCallId,
+                force: request.force,
+              }),
+              timeoutMs:
+                typeof request.timeoutMs === 'number' && request.timeoutMs > 0
+                  ? request.timeoutMs
+                  : undefined,
+              retainToolSlot: (release) => {
+                releaseToolSlot = release;
               },
-            );
-            const result = await this.executeMappedToolCallThroughModule({
-              request,
-              dispatchToolId: toolId,
-              dispatchPayload: request.input,
-              resultReceiptKey:
-                this.mappedToolResultReceiptPolicy(request).resultReceiptKey,
-              providerOperationKey,
-              resultReceipts: receipts,
-              apiOptions: {
-                playNodeScope: playNodeScopeForToolCallRequest(request),
-                durableCallReceiptKey: this.toolTransportReceiptKey({
-                  toolId,
-                  resultReceiptKey: request.receiptKey!,
-                  providerOperationKey,
-                  force: request.force,
-                }),
-                completedResultCache: true,
-                executionAuthScopeDigest: request.executionAuthScopeDigest,
-                ...this.providerForceRefreshOptionsForToolCall({
-                  operationKey:
-                    request.providerIdempotencyKeyBase ?? request.receiptKey!,
-                  force: request.force,
-                  requiresExecutionFence: request.requiresExecutionFence,
-                  logicalCallId: request.logicalCallId,
-                }),
-                timeoutMs:
-                  typeof request.timeoutMs === 'number' && request.timeoutMs > 0
-                    ? request.timeoutMs
-                    : undefined,
-                retainToolSlot: (release) => {
-                  releaseToolSlot = release;
-                },
-              },
-            });
-            await resolve(request, result, 'owner');
-          } catch (error) {
-            await reject(request, error);
-          } finally {
-            releaseToolSlot();
-          }
-        },
-      );
+            },
+          });
+          await resolve(request, result, 'owner');
+        } catch (error) {
+          await reject(request, error);
+        } finally {
+          releaseToolSlot();
+        }
+      },
+    );
 
-    await dispatchOwned(collectReadyMembers());
-    await Promise.allSettled(followerResults);
+    await Promise.all(cachedResults);
     return successful;
   }
 
@@ -16398,18 +15828,109 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
                       'Native batch Tool Call operation identity changed in transit.',
                     );
                   }
+                  const legacyForceRefreshIdentities = detail.members
+                    .filter(
+                      (member) =>
+                        member.force === true &&
+                        member.requiresExecutionFence !== true,
+                    )
+                    .map((member) =>
+                      this.providerInvocationKeyForToolCall({
+                        operationKey:
+                          this.providerOperationKeyForQueuedToolCall(member),
+                        logicalCallId: member.logicalCallId,
+                        force: true,
+                      }),
+                    );
+                  const legacyProviderOperationKey =
+                    buildDurableToolPayloadProviderIdempotencyKey({
+                      orgId: this.#options.orgId,
+                      toolId: call.tool.id,
+                      executionAuthScopeDigest:
+                        detail.members[0]?.executionAuthScopeDigest ?? null,
+                      providerActionVersion: call.tool.providerActionVersion,
+                      payload: call.payload,
+                      forceRefreshIdentities: legacyForceRefreshIdentities,
+                    });
+                  const legacyFallbackForceRefreshIdentities = detail.members
+                    .filter((member) => member.force === true)
+                    .map((member) =>
+                      this.providerInvocationKeyForToolCall({
+                        operationKey:
+                          this.providerOperationKeyForQueuedToolCall(member),
+                        logicalCallId: member.logicalCallId,
+                        force: true,
+                      }),
+                    );
+                  const legacyFallbackProviderOperationKey =
+                    buildDurableToolPayloadProviderIdempotencyKey({
+                      orgId: this.#options.orgId,
+                      toolId: call.tool.id,
+                      executionAuthScopeDigest:
+                        detail.members[0]?.executionAuthScopeDigest ?? null,
+                      providerActionVersion:
+                        (
+                          await this.#options.getToolActionCacheVersion?.(
+                            call.tool.id,
+                          )
+                        )?.trim() ?? 'unversioned',
+                      payload: call.payload,
+                      forceRefreshIdentities:
+                        legacyFallbackForceRefreshIdentities,
+                    });
                   const execution = await this.callToolExecutionAPI(
                     call.tool.id,
                     call.payload,
                     {
                       durableCallReceiptKey: this.toolTransportReceiptKey({
                         toolId: call.tool.id,
-                        resultReceiptKey: compatibility.resultReceiptKey,
                         providerOperationKey: detail.providerOperationKey,
-                        force: detail.members.some(
-                          (request) => request.force === true,
-                        ),
                       }),
+                      legacyProviderRetryIdentities: [
+                        {
+                          transportReceiptKey: detail.members.some(
+                            (member) => member.force,
+                          )
+                            ? this.toolTransportReceiptKey({
+                                toolId: call.tool.id,
+                                providerOperationKey:
+                                  legacyProviderOperationKey,
+                              })
+                            : buildDurableToolAggregateReceiptKey({
+                                receiptKeys: detail.members.map(
+                                  (member) =>
+                                    this.mappedToolResultReceiptPolicy(member)
+                                      .resultReceiptKey,
+                                ),
+                                prefix: 'batch',
+                                aggregateReceiptPrefix:
+                                  buildDurableToolReceiptPrefix({
+                                    orgId: this.#options.orgId,
+                                    toolId: call.tool.id,
+                                  }),
+                              }),
+                          providerOperationKey: legacyProviderOperationKey,
+                          forceRefreshIdentities: legacyForceRefreshIdentities,
+                        },
+                        {
+                          transportReceiptKey:
+                            buildDurableToolAggregateReceiptKey({
+                              receiptKeys: detail.members.map(
+                                (member) => member.cacheKey,
+                              ),
+                              prefix: 'batch',
+                              aggregateReceiptPrefix:
+                                buildDurableToolReceiptPrefix({
+                                  orgId: this.#options.orgId,
+                                  toolId: call.tool.id,
+                                }),
+                            }),
+                          providerOperationKey:
+                            legacyFallbackProviderOperationKey,
+                          forceRefreshIdentities:
+                            legacyFallbackForceRefreshIdentities,
+                        },
+                      ],
                       completedResultCache: true,
                       memoryLedgerRowScopes: detail.members.map((member) => ({
                         rowKey: member.rowKey,
@@ -16426,6 +15947,9 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
                       ),
                       executionAuthScopeDigest:
                         detail.members[0]?.executionAuthScopeDigest ?? null,
+                      providerIdempotencyKey: detail.providerOperationKey,
+                      providerIdempotencyReceiptKey:
+                        compatibility.resultReceiptKey,
                       ...(detail.forceRefreshIdentities.length > 0
                         ? {
                             providerOperationForceRefreshIdentities:
@@ -16535,25 +16059,12 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
                     compiled.batchOperation,
                   )
                 )?.trim() ?? '';
-              const receiptKeys = owned.map(
-                (request) =>
-                  this.mappedToolResultReceiptPolicy(request).resultReceiptKey,
-              );
-              const aggregateReceiptKey = buildDurableToolAggregateReceiptKey({
-                receiptKeys,
-                prefix: 'batch',
-                aggregateReceiptPrefix: buildDurableToolReceiptPrefix({
-                  orgId: this.#options.orgId,
-                  toolId: compiled.batchOperation,
-                }),
-              });
-              const forceRefreshIdentities = owned.flatMap((request) =>
-                this.providerForceRefreshIdentitiesForToolCall({
+              const forceRefreshIdentities = owned.map((request) =>
+                this.providerInvocationKeyForToolCall({
                   operationKey:
                     this.providerOperationKeyForQueuedToolCall(request),
-                  force: request.force,
-                  requiresExecutionFence: request.requiresExecutionFence,
                   logicalCallId: request.logicalCallId,
+                  force: request.force,
                 }),
               );
               const providerOperationKey =
@@ -16566,6 +16077,10 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
                   payload: compiled.batchPayload,
                   forceRefreshIdentities,
                 });
+              const aggregateReceiptKey = this.toolTransportReceiptKey({
+                toolId: compiled.batchOperation,
+                providerOperationKey,
+              });
               dispatchDetails.set(aggregateReceiptKey, {
                 members: owned,
                 compiled,
@@ -16659,6 +16174,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
                       toolId,
                       status: aggregate.status,
                       result: item,
+                      meta: nativeBatchResponseMeta(item),
                       toolResponse: publicToolResponseForBatchedItem(
                         aggregate,
                         item,
@@ -16825,8 +16341,6 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
         };
 
         const pendingRequests: ToolCallRequest[] = [];
-        let pendingReceiptClaimsEstablishExecutionFence =
-          this.#options.runtimeReceiptClaimsEstablishExecutionFence === true;
         const recoveredRequests: ToolCallRequest[] = [];
         for (const req of requests) {
           const cached =
@@ -16851,114 +16365,27 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
         }
         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;
-            if (follower.cacheable !== false) {
-              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,
+        const rejectCall = async (
+          request: ToolCallRequest,
           error: unknown,
         ): Promise<void> => {
-          const followers = liveFollowersByOwnerCallId.get(owner.callId) ?? [];
-          liveFollowersByOwnerCallId.delete(owner.callId);
-          if (error instanceof PlayRowProviderBackpressureError) {
-            let releaseFailure: unknown = null;
-            const receiptKey = owner.receiptKey?.trim() || null;
-            try {
-              if (receiptKey && this.durableMappedToolResultsBackedByReceipts) {
-                const leaseId = owner.receiptLeaseId?.trim();
-                if (!leaseId) {
-                  throw new Error(
-                    `Provider wait cannot release receipt ${receiptKey} without its owned lease.`,
-                  );
-                }
-                const released = await this.releaseRuntimeStepReceipt(
-                  receiptKey,
-                  this.currentReceiptOwnerRunId,
-                  leaseId,
-                );
-                if (
-                  !released ||
-                  (released.status !== 'queued' &&
-                    released.status !== 'pending')
-                ) {
-                  throw new Error(
-                    `Provider wait could not release owned receipt ${receiptKey}.`,
-                  );
-                }
-              }
-            } catch (failure) {
-              releaseFailure = failure;
-            }
-            // A provider deadline is a nonterminal control signal. The row
-            // catch records waiting metadata after the resolver unwinds; no
-            // follower may see or persist a failed receipt in between. If the
-            // lease could not be released, wake every follower with that loud
-            // infrastructure failure rather than stranding their promises.
-            for (const request of [owner, ...followers]) {
-              const resolver = this.toolCallResolvers.get(request.callId);
-              if (resolver) {
-                resolver.reject(releaseFailure ?? error);
-                this.toolCallResolvers.delete(request.callId);
-              }
-            }
-            if (releaseFailure) throw releaseFailure;
-            return;
-          }
-          const shouldPersistReceiptFailure =
-            !(error instanceof ToolExecuteAuthScopeChangedError) &&
-            !this.persistenceLatch.tripped;
-          for (const request of [owner, ...followers]) {
-            await this.rejectToolCall(toolId, request, error, {
-              persistReceiptFailure: shouldPersistReceiptFailure,
-            });
-          }
+          await this.rejectToolCall(toolId, request, error, {
+            persistReceiptFailure: false,
+          });
         };
-        const requestsWithLiveFollowers = (
-          owner: ToolCallRequest,
-        ): ToolCallRequest[] => [
-          owner,
-          ...(liveFollowersByOwnerCallId.get(owner.callId) ?? []),
-        ];
         const resolveRuntimeTimeoutMsForRequests = (
           requests: ToolCallRequest[],
         ): number | undefined => {
+          if (
+            requests.some(
+              (request) =>
+                typeof request.timeoutMs !== 'number' ||
+                !Number.isFinite(request.timeoutMs) ||
+                request.timeoutMs <= 0,
+            )
+          ) {
+            return undefined;
+          }
           const timeoutMs = Math.max(
             ...requests
               .map((request) => request.timeoutMs)
@@ -16972,76 +16399,14 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
           );
           return timeoutMs > 0 ? timeoutMs : undefined;
         };
-        const resolveRuntimeTimeoutMsForClaimedOwners = (
-          owners: ToolCallRequest[],
-        ): number | undefined => {
-          let timeoutMs = 0;
-          for (const owner of owners) {
-            if (
-              typeof owner.timeoutMs !== 'number' ||
-              !Number.isFinite(owner.timeoutMs) ||
-              owner.timeoutMs <= 0
-            ) {
-              return undefined;
-            }
-            timeoutMs = Math.max(
-              timeoutMs,
-              resolveRuntimeTimeoutMsForRequests(
-                requestsWithLiveFollowers(owner),
-              ) ?? 0,
-            );
-          }
-          return timeoutMs > 0 ? timeoutMs : undefined;
-        };
-
-        // Cacheable map members cross the real receipt-cohort boundary before
-        // the legacy claim loop. The scalar and native Modules share member
-        // receipt ownership; native batches retain their separate aggregate
-        // physical-operation receipt behind that seam. Always-fresh calls
-        // intentionally have no durable member receipt and stay below.
+        // The cohort reads completed results and publishes successful misses.
+        // Always-fresh calls have no durable member result and stay below.
         const operationStrategy =
           this.#options.getBatchOperationStrategy?.(toolId) ?? null;
-        if (
-          operationStrategy &&
-          this.durableMappedToolResultsBackedByReceipts
-        ) {
-          const cohortRequests = pendingRequests.filter(
-            (request) =>
-              request.cacheable !== false &&
-              request.requiresExecutionFence !== true &&
-              Boolean(request.receiptKey?.trim()),
-          );
-          if (cohortRequests.length > 0) {
-            const cohortCallIds = new Set(
-              cohortRequests.map((request) => request.callId),
-            );
-            pendingRequests.splice(
-              0,
-              pendingRequests.length,
-              ...pendingRequests.filter(
-                (request) => !cohortCallIds.has(request.callId),
-              ),
-            );
-            const successful =
-              await this.executeCacheableNativeMapToolCallCohort({
-                toolId,
-                requests: cohortRequests,
-                strategy: operationStrategy,
-              });
-            for (const request of successful) {
-              successfulLiveStepCallIds.add(request.callId);
-            }
-            recordToolStep(cohortRequests);
-            this.#options.onBatchComplete?.(this.checkpoint);
-          }
-        } else if (
-          !operationStrategy &&
-          this.durableMappedToolResultsBackedByReceipts
-        ) {
+        if (this.durableMappedToolResultsBackedByReceipts) {
           const cohortRequests = pendingRequests.filter(
             (request) =>
               request.cacheable !== false &&
-              request.requiresExecutionFence !== true &&
               Boolean(request.receiptKey?.trim()),
           );
           if (cohortRequests.length > 0) {
@@ -17055,1181 +16420,366 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
                 (request) => !cohortCallIds.has(request.callId),
               ),
             );
-            const successful =
-              await this.executeCacheableNonNativeMapToolCallCohort({
-                toolId,
-                requests: cohortRequests,
-              });
-            for (const request of successful) {
+            const successful = operationStrategy
+              ? await this.executeCacheableNativeMapToolCallCohort({
+                  toolId,
+                  requests: cohortRequests,
+                  strategy: operationStrategy,
+                })
+              : await this.executeCacheableNonNativeMapToolCallCohort({
+                  toolId,
+                  requests: cohortRequests,
+                });
+            for (const request of successful)
               successfulLiveStepCallIds.add(request.callId);
-            }
             recordToolStep(cohortRequests);
             this.#options.onBatchComplete?.(this.checkpoint);
           }
         }
 
-        const durableExistingRunningWaits: Array<{
-          receiptKey: string;
-          requestsForKey: ToolCallRequest[];
-          forceAfterWait: boolean;
-          waitMaxAttempts?: number;
-          /** Reclaim without polling: the prior owner's lease already expired. */
-          skipWait?: boolean;
-        }> = [];
-        const durableExistingRunningState: {
-          settlement: Promise<
-            { status: 'fulfilled' } | { status: 'rejected'; reason: unknown }
-          > | null;
-        } = { settlement: null };
-        const durableExistingRunningAbort = new AbortController();
-        // The group's size before the turn. The turn body splices and pushes
-        // `pendingRequests`, so the count read here is the only one that says
-        // how many queued calls this claim turn is blocking.
-        const claimTurnLogicalCalls = pendingRequests.length;
-        if (
-          claimTurnLogicalCalls > 0 &&
-          (this.#options.claimRuntimeStepReceipts ||
-            this.#options.claimRuntimeStepReceipt)
-        ) {
-          const requestsByReceiptKey = new Map<
-            string,
-            {
-              requests: ToolCallRequest[];
-              forceRefresh: boolean;
-              forceFailedRefresh: 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,
-              forceFailedRefresh: false,
-            };
-            group.requests.push(request);
-            group.forceRefresh ||= request.force === true;
-            group.forceFailedRefresh ||= request.forceFailedRefresh === true;
-            requestsByReceiptKey.set(receiptKey, group);
-          }
-          const normalReceiptKeys = [...requestsByReceiptKey]
-            .filter(
-              ([, group]) => !group.forceRefresh && !group.forceFailedRefresh,
-            )
-            .map(([receiptKey]) => receiptKey);
-          const forcedReceiptKeys = [...requestsByReceiptKey]
-            .filter(([, group]) => group.forceRefresh)
-            .map(([receiptKey]) => receiptKey);
-          const failedRefreshReceiptKeys = [...requestsByReceiptKey]
-            .filter(
-              ([, group]) => !group.forceRefresh && group.forceFailedRefresh,
-            )
-            .map(([receiptKey]) => receiptKey);
-          const claimStartedAt = Date.now();
-          const forcedExisting = forcedReceiptKeys.length
-            ? await this.getRuntimeStepReceipts(forcedReceiptKeys, {
-                hydrateOutput: false,
-              })
-            : new Map<string, RuntimeStepReceipt>();
-          // A forced refresh must never duplicate a provider call owned by a
-          // live lease. It can, however, immediately claim pending/unleased
-          // work and any expired lease. Waiting first for those receipts turns
-          // an already-recoverable interruption into a five-minute stall.
-          const forcedLiveReceiptKeys = new Set(
-            [...forcedExisting]
-              .filter(([, receipt]) => {
-                if (
-                  receipt.status !== 'queued' &&
-                  receipt.status !== 'pending' &&
-                  receipt.status !== 'running'
-                ) {
-                  return false;
-                }
-                if (!receipt.leaseId?.trim()) return false;
-                const expiresAt = receipt.leaseExpiresAt
-                  ? Date.parse(receipt.leaseExpiresAt)
-                  : Number.NaN;
-                // Keep an unparseable leased receipt conservative. The
-                // fenced claim remains the recovery path after the wait.
-                return !Number.isFinite(expiresAt) || expiresAt > Date.now();
-              })
-              .map(([receiptKey]) => receiptKey),
-          );
-          const claimableForcedReceiptKeys = forcedReceiptKeys.filter(
-            (receiptKey) => !forcedLiveReceiptKeys.has(receiptKey),
-          );
-          const claims =
-            normalReceiptKeys.length > 0
-              ? await this.claimRuntimeStepReceipts(
-                  normalReceiptKeys,
-                  this.currentReceiptOwnerRunId,
-                  false,
-                  false,
-                  false,
-                  false,
-                )
-              : new Map<string, RuntimeStepReceipt>();
-          const forcedClaims =
-            claimableForcedReceiptKeys.length > 0
-              ? await this.claimRuntimeStepReceipts(
-                  claimableForcedReceiptKeys,
-                  this.currentReceiptOwnerRunId,
-                  false,
-                  true,
-                  false,
-                )
-              : new Map<string, RuntimeStepReceipt>();
-          const failedRefreshClaims =
-            failedRefreshReceiptKeys.length > 0
-              ? await this.claimRuntimeStepReceipts(
-                  failedRefreshReceiptKeys,
-                  this.currentReceiptOwnerRunId,
-                  false,
-                  false,
-                  true,
-                  false,
-                )
-              : new Map<string, RuntimeStepReceipt>();
-          for (const [receiptKey, claim] of forcedClaims) {
-            claims.set(receiptKey, claim);
-          }
-          for (const [receiptKey, claim] of failedRefreshClaims) {
-            claims.set(receiptKey, claim);
-          }
-          const safeFailedReceiptKeys = [...claims]
-            .filter(([, claim]) => this.canRetryWithoutProviderDispatch(claim))
-            .map(([receiptKey]) => receiptKey);
-          if (safeFailedReceiptKeys.length > 0) {
-            const refreshed = await this.claimRuntimeStepReceipts(
-              safeFailedReceiptKeys,
-              this.currentReceiptOwnerRunId,
-              false,
-              false,
-              true,
-              false,
-            );
-            for (const [receiptKey, claim] of refreshed) {
-              claims.set(receiptKey, claim);
-            }
-          }
-          // Claiming is a state transition, not a reason to expand a
-          // body. Fresh receipts contain no result, yet the old path took
-          // the hydration lane before it learned that fact and charged a
-          // multi-MB row prior to every one. Claims now arrive as bounded
-          // manifests; only a terminal winner redeems its known-size body
-          // under a second, byte-priced turn.
-          const terminalClaimKeys = [...claims]
-            .filter(
-              ([, claim]) =>
-                (claim.status === 'completed' || claim.status === 'skipped') &&
-                claim.output === undefined,
-            )
-            .map(([receiptKey]) => receiptKey);
-          if (terminalClaimKeys.length > 0) {
-            const hasBoundedClaimManifests = terminalClaimKeys.every(
-              (receiptKey) => {
-                const claim = claims.get(receiptKey);
-                return (
-                  Number.isSafeInteger(claim?.outputByteLength) &&
-                  (claim?.outputByteLength ?? -1) >= 0
-                );
-              },
-            );
-            const expectedClaimBytes = hasBoundedClaimManifests
-              ? terminalClaimKeys.reduce(
-                  (total, receiptKey) =>
-                    total + (claims.get(receiptKey)?.outputByteLength ?? 0),
-                  0,
-                )
-              : undefined;
-            const hydratedClaims = await this.withRuntimeReceiptHydrationTurn(
-              async (hydrationTurn) => {
-                const receipts =
-                  await this.getRuntimeStepReceipts(terminalClaimKeys);
-                hydrationTurn.settleBytes(
-                  runtimeStepReceiptPayloadBytes(receipts.values()),
-                );
-                return receipts;
-              },
-              {
-                logicalCalls: claimTurnLogicalCalls,
-                receiptKeys: terminalClaimKeys.length,
-                ...(expectedClaimBytes !== undefined
-                  ? { expectedBytes: expectedClaimBytes }
-                  : {}),
-                source: 'map_legacy_claim',
-              },
-            );
-            for (const [receiptKey, receipt] of hydratedClaims) {
-              claims.set(receiptKey, receipt);
-            }
-          }
-          // Every get/claim round trip this dispatch group paid before any
-          // provider work could start.
-          this.resourceGovernor.observe({
-            receiptClaimMs: Date.now() - claimStartedAt,
-          });
-          // Claims are compact state transitions. They do not own output
-          // bytes and must not wait behind the hydration lane's global
-          // memory headroom; a terminal manifest above is the only path
-          // that opens a byte-admitted hydration turn.
-          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(`${source} tool recovery needs receipt key.`);
-            }
-            const wrapped = await this.wrapToolExecutionResult({
-              toolId,
-              status:
-                receipt.output === null || receipt.output === undefined
-                  ? 'no_result'
-                  : 'completed',
-              result: this.runtimeReceiptOutput(receipt),
-              requestInput: request.input,
-              execution: toolExecutionMetadataForOutcome({
-                kind: source,
-                cacheKey: request.cacheKey,
-                receiptKey,
-                attachedToReceiptKey: receiptKey,
-              }),
-            });
-            this.cacheToolResult(toolId, request.cacheKey, wrapped);
-            for (const waitingRequest of requestsForKey) {
-              successfulLiveStepCallIds.add(waitingRequest.callId);
-              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 resolveReceiptWaitMaxAttempts = (
-            requestsForKey: ToolCallRequest[],
-          ): number | undefined =>
-            requestsForKey.length > 0
-              ? Math.max(
-                  ...requestsForKey.map((request) =>
-                    resolveRuntimeToolReceiptWaitMaxAttempts(
-                      typeof request.receiptWaitMs === 'number'
-                        ? { max_wait_ms: request.receiptWaitMs }
-                        : request.input,
-                    ),
-                  ),
-                )
-              : undefined;
-          const queueExistingRunningReceiptWait = (
-            receiptKey: string,
-            requestsForKey: ToolCallRequest[],
-            forceAfterWait = false,
-            skipWait = false,
-          ): void => {
-            durableExistingRunningWaits.push({
-              receiptKey,
-              requestsForKey,
-              forceAfterWait,
-              waitMaxAttempts: resolveReceiptWaitMaxAttempts(requestsForKey),
-              skipWait,
+        if (pendingRequests.length > 0) {
+          const strategy = operationStrategy;
+
+          if (strategy) {
+            const compiledBatches = compileRequestsWithStrategy({
+              requests: pendingRequests,
+              strategy,
+              getPayload: (request: ToolCallRequest) => request.input,
             });
-          };
-          const reclaimExistingRunningReceiptAfterWait = async (
-            receiptKey: string,
-            requestsForKey: ToolCallRequest[],
-            forceAfterWait = false,
-            waitResult?: {
-              completedReceipt?: RuntimeStepReceipt;
-              skipWait?: boolean;
-            },
-          ): Promise<void> => {
-            if (waitResult?.completedReceipt) {
-              if (!forceAfterWait) {
-                await resolveRequestsFromReceipt(
-                  requestsForKey,
-                  waitResult.completedReceipt,
-                  'in_flight',
-                );
-                return;
-              }
-            } else if (waitResult?.skipWait !== true) {
-              const waitMaxAttempts =
-                resolveReceiptWaitMaxAttempts(requestsForKey);
-              try {
-                const completed = await this.waitForCompletedRuntimeToolReceipt(
-                  receiptKey,
-                  waitMaxAttempts,
-                );
-                if (!forceAfterWait) {
-                  await resolveRequestsFromReceipt(
-                    requestsForKey,
-                    completed,
-                    'in_flight',
-                  );
-                  return;
-                }
-              } catch (error) {
-                if (!(error instanceof RuntimeReceiptWaitTimeoutError)) {
-                  for (const request of requestsForKey) {
-                    await this.rejectToolCall(toolId, request, error, {
-                      persistReceiptFailure: false,
-                    });
-                  }
-                  return;
-                }
-              }
-            }
-            const reclaimed = (
-              await this.claimRuntimeStepReceipts(
-                [receiptKey],
-                this.currentReceiptOwnerRunId,
-                true,
-                forceAfterWait,
-              )
-            ).get(receiptKey);
-            if (
-              reclaimed?.status === 'completed' ||
-              reclaimed?.status === 'skipped'
-            ) {
-              await resolveRequestsFromReceipt(
-                requestsForKey,
-                reclaimed,
-                'cache',
-              );
-              durableRecoveredRequests.push(...requestsForKey);
-              return;
-            }
-            if (reclaimed?.status === 'failed') {
-              for (const request of requestsForKey) {
-                await this.rejectToolCall(
-                  toolId,
-                  request,
-                  runtimeReceiptFailureError(
-                    reclaimed,
-                    'Durable tool call failed',
-                    this.currentToolErrorSchemaVersion,
-                  ),
-                );
-              }
-              return;
-            }
-            if (this.isOwnedClaimedRuntimeReceipt(reclaimed)) {
-              const [owner, ...waiters] = requestsForKey;
-              if (!owner) return;
-              if (!reclaimed.leaseId) {
-                throw new RuntimeReceiptLeaseLostError({
-                  receiptKey,
-                  runId: this.currentReceiptOwnerRunId,
-                  leaseId: 'missing',
-                });
-              }
-              owner.receiptLeaseId = reclaimed.leaseId ?? null;
-              owner.receiptLeaseExpiresAt = reclaimed.leaseExpiresAt ?? null;
-              if (waiters.length > 0) {
-                liveFollowersByOwnerCallId.set(owner.callId, waiters);
-              }
-              try {
-                // Circuit breaker: a receipt reclaimed after its owner's lease
-                // lapsed is still a fresh provider call, and the latch may
-                // have tripped while this group waited for that lease.
+
+            const batchParallelismCeiling =
+              this.governor.policy.pacing.workerToolBatchDefaultParallelism;
+            const batchSize =
+              compiledBatches.length > 0
+                ? await this.resourceGovernor.suggestedToolParallelism(
+                    compiledBatches[0]!.batchOperation,
+                    batchParallelismCeiling,
+                  )
+                : batchParallelismCeiling;
+            await executeChunkedRequests({
+              requests: compiledBatches,
+              batchSize,
+              execute: async (batch) => {
+                // Circuit breaker: skip dispatching this batch's provider call
+                // once a persistence failure has occurred in this run.
                 if (this.persistenceLatch.tripped) {
                   this.persistenceLatch.preventedCallCount +=
-                    requestsForKey.length;
+                    batch.memberRequests.length;
                   throw new RuntimePersistenceCircuitOpenError(
                     this.persistenceLatch,
                   );
                 }
-                const execution = await this.executeMappedToolCallThroughModule(
-                  {
-                    request: owner,
-                    dispatchToolId: toolId,
-                    dispatchPayload: owner.input,
-                    resultReceiptKey: receiptKey,
-                    providerOperationKey:
-                      this.providerOperationKeyForQueuedToolCall(owner),
-                    apiOptions: {
-                      beforeProviderCall: () =>
-                        this.assertRuntimeToolReceiptOwnership([owner]),
-                      durableCallReceiptKey: receiptKey,
-                      playNodeScope: playNodeScopeForToolCallRequest(owner),
-                      executionAuthScopeDigest: owner.executionAuthScopeDigest,
-                      receiptLeaseExpiresAt: owner.receiptLeaseExpiresAt,
-                      heartbeatReceipt: () =>
-                        this.renewRuntimeToolReceiptOwnership([owner]),
-                      providerIdempotencyKey:
-                        this.providerIdempotencyKeyForToolCall({
-                          operationKey:
-                            this.providerOperationKeyForQueuedToolCall(owner),
-                          force: owner.force === true,
-                          logicalCallId: owner.logicalCallId,
-                        }),
-                      ...this.providerForceRefreshOptionsForToolCall({
-                        operationKey:
-                          this.providerOperationKeyForQueuedToolCall(owner),
-                        force: owner.force,
-                        requiresExecutionFence: owner.requiresExecutionFence,
-                        logicalCallId: owner.logicalCallId,
-                      }),
-                      timeoutMs: resolveRuntimeTimeoutMsForClaimedOwners([
-                        owner,
-                      ]),
-                    },
-                  },
-                );
-                const result = await this.resolveToolCall(
-                  toolId,
-                  owner,
-                  execution,
-                );
-                if (result != null) {
-                  successfulLiveStepCallIds.add(owner.callId);
-                }
-                resolveLiveFollowers(owner, result);
-                recordToolStep([owner]);
-                this.#options.onBatchComplete?.(this.checkpoint);
-              } catch (error) {
-                await rejectWithLiveFollowers(owner, error);
-              }
-              return;
-            }
-            for (const request of requestsForKey) {
-              await this.rejectToolCall(
-                toolId,
-                request,
-                new RuntimeReceiptWaitTimeoutError(receiptKey),
-                { persistReceiptFailure: false },
-              );
-            }
-            return;
-          };
-          const reclaimExistingRunningReceipts = async (
-            waits: Array<(typeof durableExistingRunningWaits)[number]>,
-          ): Promise<void> => {
-            if (waits.length === 0) return;
-            const settlements = await Promise.allSettled(
-              waits.map((wait) =>
-                reclaimExistingRunningReceiptAfterWait(
-                  wait.receiptKey,
-                  wait.requestsForKey,
-                  wait.forceAfterWait,
-                  { skipWait: true },
-                ),
-              ),
-            );
-            const rejected = settlements.find(
-              (settlement) => settlement.status === 'rejected',
-            );
-            if (rejected?.status === 'rejected') throw rejected.reason;
-          };
-          const processExistingRunningReceiptWaits =
-            async (): Promise<void> => {
-              if (durableExistingRunningWaits.length === 0) return;
-              const waitSignal = durableExistingRunningAbort.signal;
-              // A claim that came back `existing` behind an expired lease is
-              // not blocked on live work; it is holding a dead run's row.
-              // Reclaim those now so this run executes the call itself, and
-              // poll only the leases that are genuinely still alive.
-              const expiredLeaseWaits = durableExistingRunningWaits.filter(
-                (wait) => wait.skipWait === true,
-              );
-              const pendingWaits = new Map(
-                durableExistingRunningWaits
-                  .filter((wait) => wait.skipWait !== true)
-                  .map((wait) => [wait.receiptKey, wait]),
-              );
-              const parkedAtMs = Date.now();
-              for (const wait of durableExistingRunningWaits) {
-                this.#runtimeReceiptWaitParking.set(wait.receiptKey, {
-                  startedAtMs: parkedAtMs,
-                  rows: wait.requestsForKey.length,
-                  stage:
-                    wait.skipWait === true
-                      ? 'expired_lease_reclaim'
-                      : 'receipt_lease_wait',
-                });
-              }
-              const pollWaits = async (): Promise<void> => {
-                if (pendingWaits.size === 0) return;
-                const waitMaxAttempts =
-                  Math.max(
-                    ...[...pendingWaits.values()].map(
-                      (wait) => wait.waitMaxAttempts ?? 0,
-                    ),
-                  ) || DURABLE_RECEIPT_WAIT_MAX_ATTEMPTS;
-                // The backoff cap means the attempt count no longer states a
-                // wall time. This deadline is the budget those attempts were
-                // meant to express; crossing it falls through to the same
-                // reclaim path an expired lease takes.
-                const waitDeadline =
-                  Date.now() +
-                  runtimeReceiptWaitBudgetMs(
-                    waitMaxAttempts,
-                    DURABLE_RECEIPT_WAIT_DELAY_MS,
+                const aggregateForceRefreshIdentities =
+                  batch.memberRequests.map((request) =>
+                    this.providerInvocationKeyForToolCall({
+                      operationKey:
+                        this.providerOperationKeyForQueuedToolCall(request),
+                      logicalCallId: request.logicalCallId,
+                      force: request.force,
+                    }),
                   );
-                if (runtimeReceiptReadTraceEnabled) {
-                  this.runtimeLog(
-                    `[runtime-receipt-wait] phase=start requested=${pendingWaits.size} ` +
-                      `request_digests=${[...pendingWaits.keys()]
-                        .map(runtimeReceiptKeyDigest)
-                        .join(',')} max_attempts=${waitMaxAttempts}`,
+                const legacyForceRefreshIdentities = batch.memberRequests
+                  .filter((request) => request.force === true)
+                  .map((request) =>
+                    this.providerInvocationKeyForToolCall({
+                      operationKey:
+                        this.providerOperationKeyForQueuedToolCall(request),
+                      logicalCallId: request.logicalCallId,
+                      force: true,
+                    }),
                   );
-                }
-                for (
-                  let attempt = 0;
-                  attempt < waitMaxAttempts && pendingWaits.size > 0;
-                  attempt += 1
-                ) {
-                  if (waitSignal.aborted) return;
-                  if (attempt > 0) {
-                    if (Date.now() >= waitDeadline) break;
-                    const delayMs = Math.min(
-                      runtimeReceiptWaitDelayMs(attempt),
-                      Math.max(0, waitDeadline - Date.now()),
-                    );
-                    await new Promise<void>((resolve) => {
-                      const finish = () => {
-                        clearTimeout(timeout);
-                        waitSignal.removeEventListener('abort', finish);
-                        resolve();
-                      };
-                      const timeout = setTimeout(finish, delayMs);
-                      waitSignal.addEventListener('abort', finish, {
-                        once: true,
-                      });
-                    });
-                    if (waitSignal.aborted) return;
-                  }
-                  // The long backoff lives outside the hydration lane. Only a
-                  // bounded receipt read and delivery hold the lane, so stale
-                  // ownership cannot block unrelated cache misses/provider
-                  // work while terminal payloads still hydrate one group at a
-                  // time.
-                  try {
-                    await this.withRuntimeReceiptHydrationTurn(
-                      async (turn) => {
-                        if (waitSignal.aborted) return;
-                        const waited =
-                          await this.waitForCompletedRuntimeToolReceipts(
-                            [...pendingWaits.keys()],
-                            1,
-                          );
-                        turn.settleBytes(
-                          runtimeStepReceiptPayloadBytes(
-                            waited.completed.values(),
-                          ),
-                        );
-                        if (waitSignal.aborted) return;
-                        const settledWaits = [...pendingWaits.values()].filter(
-                          (wait) =>
-                            waited.completed.has(wait.receiptKey) ||
-                            waited.failed.has(wait.receiptKey),
-                        );
-                        const deliverySettlements = await Promise.allSettled(
-                          settledWaits.map(async (wait) => {
-                            const failed = waited.failed.get(wait.receiptKey);
-                            if (failed) {
-                              for (const request of wait.requestsForKey) {
-                                await this.rejectToolCall(
-                                  toolId,
-                                  request,
-                                  failed,
-                                  {
-                                    persistReceiptFailure: false,
-                                  },
-                                );
-                              }
-                              return;
-                            }
-                            await reclaimExistingRunningReceiptAfterWait(
-                              wait.receiptKey,
-                              wait.requestsForKey,
-                              wait.forceAfterWait,
-                              {
-                                completedReceipt: waited.completed.get(
-                                  wait.receiptKey,
+                const batchActionVersion =
+                  (
+                    await this.#options.getToolActionCacheVersion?.(
+                      batch.batchOperation,
+                    )
+                  )?.trim() ?? 'unversioned';
+                const aggregateProviderOperationKey =
+                  buildDurableToolPayloadProviderIdempotencyKey({
+                    orgId: this.#options.orgId,
+                    toolId: batch.batchOperation,
+                    executionAuthScopeDigest:
+                      batch.memberRequests[0]?.executionAuthScopeDigest ?? null,
+                    providerActionVersion: batchActionVersion,
+                    payload: batch.batchPayload,
+                    forceRefreshIdentities: aggregateForceRefreshIdentities,
+                  });
+                const aggregateReceiptKey = this.toolTransportReceiptKey({
+                  toolId: batch.batchOperation,
+                  providerOperationKey: aggregateProviderOperationKey,
+                });
+                let releaseToolSlot: () => void = () => undefined;
+                try {
+                  const execution =
+                    await this.executeMappedToolCallThroughModule({
+                      request: batch.memberRequests[0]!,
+                      dispatchToolId: batch.batchOperation,
+                      dispatchPayload: batch.batchPayload,
+                      resultReceiptKey: aggregateReceiptKey,
+                      providerOperationKey: aggregateProviderOperationKey,
+                      apiOptions: {
+                        durableCallReceiptKey: aggregateReceiptKey,
+                        legacyProviderRetryIdentities: [
+                          {
+                            transportReceiptKey:
+                              buildDurableToolAggregateReceiptKey({
+                                receiptKeys: batch.memberRequests.map(
+                                  (member) => member.cacheKey,
                                 ),
-                                skipWait: true,
-                              },
-                            );
-                          }),
-                        );
-                        for (
-                          let index = 0;
-                          index < settledWaits.length;
-                          index += 1
-                        ) {
-                          if (
-                            deliverySettlements[index]?.status === 'fulfilled'
-                          ) {
-                            const settledKey = settledWaits[index]!.receiptKey;
-                            pendingWaits.delete(settledKey);
-                            this.#runtimeReceiptWaitParking.delete(settledKey);
-                          }
-                        }
-                        if (runtimeReceiptReadTraceEnabled) {
-                          const rejected = deliverySettlements.flatMap(
-                            (settlement, index) => {
-                              if (settlement.status !== 'rejected') return [];
-                              const receiptKey =
-                                settledWaits[index]?.receiptKey;
-                              return receiptKey
-                                ? [
-                                    `${runtimeReceiptKeyDigest(receiptKey)}:${
-                                      settlement.reason instanceof Error
-                                        ? settlement.reason.name
-                                        : 'non_error'
-                                    }`,
-                                  ]
-                                : ['unknown'];
-                            },
-                          );
-                          this.runtimeLog(
-                            `[runtime-receipt-wait] phase=delivery settled=${deliverySettlements.length} ` +
-                              `rejected=${rejected.length} rejected_digests=${rejected.join(',')}`,
-                          );
-                        }
-                        const rejectedDelivery = deliverySettlements.find(
-                          (settlement) => settlement.status === 'rejected',
-                        );
-                        if (rejectedDelivery?.status === 'rejected') {
-                          throw rejectedDelivery.reason;
-                        }
-                      },
-                      {
-                        receiptKeys: pendingWaits.size,
-                        source: 'map_receipt_wait',
-                        // The lane wait is part of this loop's budget, not
-                        // extra time on top of it.
-                        timeoutMs: Math.max(0, waitDeadline - Date.now()),
+                                prefix: 'batch',
+                                aggregateReceiptPrefix:
+                                  buildDurableToolReceiptPrefix({
+                                    orgId: this.#options.orgId,
+                                    toolId: batch.batchOperation,
+                                  }),
+                              }),
+                            providerOperationKey:
+                              buildDurableToolPayloadProviderIdempotencyKey({
+                                orgId: this.#options.orgId,
+                                toolId: batch.batchOperation,
+                                executionAuthScopeDigest:
+                                  batch.memberRequests[0]
+                                    ?.executionAuthScopeDigest ?? null,
+                                providerActionVersion: batchActionVersion,
+                                payload: batch.batchPayload,
+                                forceRefreshIdentities:
+                                  legacyForceRefreshIdentities,
+                              }),
+                            forceRefreshIdentities:
+                              legacyForceRefreshIdentities,
+                          },
+                        ],
+                        // A native batch is one physical provider request for
+                        // many rows of the same column, so the batch's node scope
+                        // is its members' shared scope.
+                        playNodeScope: playNodeScopeForToolCallRequest(
+                          batch.memberRequests[0]!,
+                          batch.batchOperation,
+                        ),
+                        executionAuthScopeDigest:
+                          batch.memberRequests[0]?.executionAuthScopeDigest ??
+                          null,
+                        providerIdempotencyKey: aggregateProviderOperationKey,
+                        providerOperationForceRefreshIdentities:
+                          aggregateForceRefreshIdentities,
+                        receiptLeaseExpiresAt: batch.memberRequests.reduce<
+                          string | null
+                        >((earliest, request) => {
+                          const expiresAt =
+                            request.receiptLeaseExpiresAt ?? null;
+                          if (!expiresAt) return earliest;
+                          if (!earliest) return expiresAt;
+                          return Date.parse(expiresAt) < Date.parse(earliest)
+                            ? expiresAt
+                            : earliest;
+                        }, null),
+                        timeoutMs: resolveRuntimeTimeoutMsForRequests(
+                          batch.memberRequests,
+                        ),
+                        retainToolSlot: (release) => {
+                          releaseToolSlot = release;
+                        },
                       },
-                    );
-                  } catch (error) {
-                    // The budget is spent, not the run: fall through to the
-                    // same reclaim an expired lease takes.
-                    if (
-                      !(
-                        error instanceof RuntimeReceiptHydrationTurnTimeoutError
-                      )
-                    ) {
-                      throw error;
-                    }
-                    break;
-                  }
-                }
-                if (waitSignal.aborted) return;
-                await reclaimExistingRunningReceipts([
-                  ...pendingWaits.values(),
-                ]);
-              };
-              try {
-                const lanes = await Promise.allSettled([
-                  reclaimExistingRunningReceipts(expiredLeaseWaits),
-                  pollWaits(),
-                ]);
-                const rejectedLane = lanes.find(
-                  (lane) => lane.status === 'rejected',
-                );
-                if (rejectedLane?.status === 'rejected') {
-                  throw rejectedLane.reason;
-                }
-              } finally {
-                for (const wait of durableExistingRunningWaits) {
-                  this.#runtimeReceiptWaitParking.delete(wait.receiptKey);
+                    });
+                  return { execution, releaseToolSlot };
+                } catch (error) {
+                  releaseToolSlot();
+                  throw error;
                 }
-              }
-            };
-
-          for (const [receiptKey, group] of requestsByReceiptKey) {
-            const requestsForKey = group.requests;
-            const claim = claims.get(receiptKey);
-            if (!claim) {
-              queueExistingRunningReceiptWait(
-                receiptKey,
-                requestsForKey,
-                group.forceRefresh,
-              );
-              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,
-                  runtimeReceiptFailureError(
-                    claim,
-                    'Durable tool call failed',
-                    this.currentToolErrorSchemaVersion,
-                  ),
-                );
-              }
-              continue;
-            }
-            if (
-              (claim?.status === 'queued' ||
-                claim?.status === 'pending' ||
-                claim?.status === 'running') &&
-              claim.claimState === 'existing'
-            ) {
-              queueExistingRunningReceiptWait(
-                receiptKey,
-                requestsForKey,
-                group.forceRefresh,
-                !runtimeReceiptClaimLeaseIsLive(claim),
-              );
-              continue;
-            }
-            if (this.isOwnedClaimedRuntimeReceipt(claim)) {
-              const [owner, ...waiters] = requestsForKey;
-              if (!claim.leaseId) {
-                throw new RuntimeReceiptLeaseLostError({
-                  receiptKey,
-                  runId: this.currentReceiptOwnerRunId,
-                  leaseId: 'missing',
-                });
-              }
-              if (owner) {
-                owner.receiptLeaseId = claim.leaseId ?? null;
-                owner.receiptLeaseExpiresAt = claim.leaseExpiresAt ?? null;
-                const claimLeaseExpiresAtMs = Date.parse(
-                  claim.leaseExpiresAt ?? '',
-                );
-                pendingReceiptClaimsEstablishExecutionFence &&=
-                  claim.claimState === 'claimed' &&
-                  claim.status === 'running' &&
-                  Number.isFinite(claimLeaseExpiresAtMs) &&
-                  claimLeaseExpiresAtMs > Date.now();
-              }
-              claimOwnerWithLiveFollowers(owner, waiters);
-              continue;
-            }
-            queueExistingRunningReceiptWait(
-              receiptKey,
-              requestsForKey,
-              group.forceRefresh,
-            );
-          }
-
-          pendingRequests.length = 0;
-          pendingRequests.push(...claimedRequests);
-          durableExistingRunningState.settlement =
-            durableExistingRunningWaits.length > 0
-              ? processExistingRunningReceiptWaits().then(
-                  () => ({ status: 'fulfilled' as const }),
-                  (reason: unknown) => ({
-                    status: 'rejected' as const,
-                    reason,
-                  }),
-                )
-              : null;
-          recordToolStep(durableRecoveredRequests);
-        }
-
-        // Claims establish one lease cohort. Revalidate that cohort in one
-        // gateway operation before provider admission, then let the existing
-        // cohort heartbeat keep the undispatched tail alive. Revalidating each
-        // call separately after a tool slot opens fragments the writer into
-        // one-row batches and starves otherwise healthy providers.
-        const pendingReceiptHeartbeat = this.startPendingToolReceiptHeartbeat(
-          pendingRequests,
-          pendingReceiptClaimsEstablishExecutionFence,
-        );
-        let providerFailure: { reason: unknown } | null = null;
-        try {
-          if (pendingReceiptHeartbeat) {
-            await pendingReceiptHeartbeat.confirmOwned();
-          }
-          if (pendingRequests.length > 0) {
-            const strategy = operationStrategy;
-
-            if (strategy) {
-              const compiledBatches = compileRequestsWithStrategy({
-                requests: pendingRequests,
-                strategy,
-                getPayload: (request: ToolCallRequest) => request.input,
-              });
-
-              const batchParallelismCeiling =
-                this.governor.policy.pacing.workerToolBatchDefaultParallelism;
-              const batchSize =
-                compiledBatches.length > 0
-                  ? await this.resourceGovernor.suggestedToolParallelism(
-                      compiledBatches[0]!.batchOperation,
-                      batchParallelismCeiling,
-                    )
-                  : batchParallelismCeiling;
-              await executeChunkedRequests({
-                requests: compiledBatches,
-                batchSize,
-                execute: async (batch) => {
-                  // Circuit breaker: skip dispatching this batch's provider call
-                  // once a persistence failure has occurred in this run.
-                  if (this.persistenceLatch.tripped) {
-                    this.persistenceLatch.preventedCallCount +=
-                      batch.memberRequests.length;
-                    throw new RuntimePersistenceCircuitOpenError(
-                      this.persistenceLatch,
+              },
+              onChunkComplete: async (chunkResults) => {
+                for (const entry of chunkResults) {
+                  if (entry.error !== undefined) {
+                    const settlements = await Promise.allSettled(
+                      entry.request.memberRequests.map((request) =>
+                        rejectCall(request, entry.error),
+                      ),
                     );
-                  }
-                  const receiptKeys = batch.memberRequests.map(
-                    (request) => request.cacheKey,
-                  );
-                  const aggregateReceiptKey =
-                    buildDurableToolAggregateReceiptKey({
-                      receiptKeys,
-                      prefix: 'batch',
-                      aggregateReceiptPrefix: buildDurableToolReceiptPrefix({
-                        orgId: this.#options.orgId,
-                        toolId: batch.batchOperation,
-                      }),
-                    });
-                  const aggregateForceRefreshIdentities = batch.memberRequests
-                    .filter((request) => request.force === true)
-                    .map((request) =>
-                      this.providerIdempotencyKeyForToolCall({
-                        operationKey:
-                          this.providerOperationKeyForQueuedToolCall(request),
-                        force: true,
-                        logicalCallId: request.logicalCallId,
-                      }),
+                    const rejected = settlements.find(
+                      (settlement): settlement is PromiseRejectedResult =>
+                        settlement.status === 'rejected',
                     );
-                  const aggregateProviderOperationKey =
-                    buildDurableToolPayloadProviderIdempotencyKey({
-                      orgId: this.#options.orgId,
-                      toolId: batch.batchOperation,
-                      executionAuthScopeDigest:
-                        batch.memberRequests[0]?.executionAuthScopeDigest ??
-                        null,
-                      providerActionVersion:
-                        (
-                          await this.#options.getToolActionCacheVersion?.(
-                            batch.batchOperation,
-                          )
-                        )?.trim() ?? 'unversioned',
-                      payload: batch.batchPayload,
-                      forceRefreshIdentities: aggregateForceRefreshIdentities,
-                    });
-                  let releaseToolSlot: () => void = () => undefined;
+                    if (rejected) throw rejected.reason;
+                    continue;
+                  }
+                  const batchExecution = entry.result;
                   try {
-                    const execution =
-                      await this.executeMappedToolCallThroughModule({
-                        request: batch.memberRequests[0]!,
-                        dispatchToolId: batch.batchOperation,
-                        dispatchPayload: batch.batchPayload,
-                        resultReceiptKey: aggregateReceiptKey,
-                        providerOperationKey: aggregateProviderOperationKey,
-                        apiOptions: {
-                          durableCallReceiptKey: aggregateReceiptKey,
-                          // A native batch is one physical provider request for
-                          // many rows of the same column, so the batch's node scope
-                          // is its members' shared scope.
-                          playNodeScope: playNodeScopeForToolCallRequest(
-                            batch.memberRequests[0]!,
-                            batch.batchOperation,
-                          ),
-                          executionAuthScopeDigest:
-                            batch.memberRequests[0]?.executionAuthScopeDigest ??
-                            null,
-                          providerIdempotencyKey: aggregateProviderOperationKey,
-                          providerOperationForceRefreshIdentities:
-                            aggregateForceRefreshIdentities,
-                          receiptLeaseExpiresAt: batch.memberRequests.reduce<
-                            string | null
-                          >((earliest, request) => {
-                            const expiresAt =
-                              request.receiptLeaseExpiresAt ?? null;
-                            if (!expiresAt) return earliest;
-                            if (!earliest) return expiresAt;
-                            return Date.parse(expiresAt) < Date.parse(earliest)
-                              ? expiresAt
-                              : earliest;
-                          }, null),
-                          timeoutMs: resolveRuntimeTimeoutMsForClaimedOwners(
-                            batch.memberRequests,
+                    const splitResults =
+                      batchExecution != null
+                        ? entry.request.splitResults(
+                            legacyResultForBatchSplitter(
+                              batchExecution.execution,
+                            ),
+                          )
+                        : entry.request.memberRequests.map(() => null);
+                    const resolvedResults =
+                      await this.resolveToolCallBatchResults(
+                        toolId,
+                        entry.request.memberRequests.map((request, index) => ({
+                          request,
+                          result: splitResults[index] ?? null,
+                          status: batchExecution?.execution.status,
+                          meta: nativeBatchResponseMeta(
+                            splitResults[index] ?? null,
                           ),
-                          beforeProviderCall: () =>
-                            pendingReceiptHeartbeat
-                              ? pendingReceiptHeartbeat.assertOwned()
-                              : this.assertRuntimeToolReceiptOwnership(
-                                  batch.memberRequests,
+                          toolResponse:
+                            batchExecution == null
+                              ? undefined
+                              : publicToolResponseForBatchedItem(
+                                  batchExecution.execution,
+                                  splitResults[index] ?? null,
+                                  true,
                                 ),
-                          heartbeatReceipt: () =>
-                            this.renewRuntimeToolReceiptOwnership(
-                              batch.memberRequests,
-                            ),
-                          retainToolSlot: (release) => {
-                            releaseToolSlot = release;
-                          },
-                        },
-                      });
-                    return { execution, releaseToolSlot };
-                  } catch (error) {
-                    releaseToolSlot();
-                    throw error;
-                  }
-                },
-                onChunkComplete: async (chunkResults) => {
-                  for (const entry of chunkResults) {
-                    if (entry.error !== undefined) {
-                      const settlements = await Promise.allSettled(
-                        entry.request.memberRequests.map((request) =>
-                          rejectWithLiveFollowers(request, entry.error),
-                        ),
-                      );
-                      const rejected = settlements.find(
-                        (settlement): settlement is PromiseRejectedResult =>
-                          settlement.status === 'rejected',
+                        })),
                       );
-                      if (rejected) throw rejected.reason;
-                      continue;
-                    }
-                    const batchExecution = entry.result;
-                    try {
-                      const splitResults =
-                        batchExecution != null
-                          ? entry.request.splitResults(
-                              legacyResultForBatchSplitter(
-                                batchExecution.execution,
-                              ),
-                            )
-                          : entry.request.memberRequests.map(() => null);
-                      const resolvedResults =
-                        await this.resolveToolCallBatchResults(
-                          toolId,
-                          entry.request.memberRequests.map(
-                            (request, index) => ({
-                              request,
-                              result: splitResults[index] ?? null,
-                              status: batchExecution?.execution.status,
-                              toolResponse:
-                                batchExecution == null
-                                  ? undefined
-                                  : publicToolResponseForBatchedItem(
-                                      batchExecution.execution,
-                                      splitResults[index] ?? null,
-                                      true,
-                                    ),
-                            }),
-                          ),
-                        );
 
-                      for (
-                        let index = 0;
-                        index < entry.request.memberRequests.length;
-                        index += 1
-                      ) {
-                        const request = entry.request.memberRequests[index]!;
-                        if (resolvedResults[index] != null) {
-                          successfulLiveStepCallIds.add(request.callId);
-                        }
-                        resolveLiveFollowers(request, resolvedResults[index]);
+                    for (
+                      let index = 0;
+                      index < entry.request.memberRequests.length;
+                      index += 1
+                    ) {
+                      const request = entry.request.memberRequests[index]!;
+                      if (resolvedResults[index] != null) {
+                        successfulLiveStepCallIds.add(request.callId);
                       }
-                    } finally {
-                      batchExecution?.releaseToolSlot();
                     }
+                  } finally {
+                    batchExecution?.releaseToolSlot();
                   }
+                }
 
-                  recordToolStep(
-                    chunkResults.flatMap(
-                      (entry) => entry.request.memberRequests,
-                    ),
-                  );
-                  this.#options.onBatchComplete?.(this.checkpoint);
-                },
-                retainResults: false,
-              });
-            } else {
-              // Bound direct map dispatch separately from ordinary provider
-              // residency. This prevents a blocked first chunk from launching
-              // another chunk ahead of a provider's admitted start rate, while
-              // preserving the wider resident-call capacity used by batched and
-              // high-latency providers.
-              const toolCallConcurrencyCeiling =
-                this.governor.policy.concurrency.toolCalls;
-              const shapedToolParallelism =
-                await this.resourceGovernor.suggestedDirectToolParallelism(
-                  toolId,
-                  toolCallConcurrencyCeiling,
+                recordToolStep(
+                  chunkResults.flatMap((entry) => entry.request.memberRequests),
                 );
-              const dispatchWidth = Math.min(
+                this.#options.onBatchComplete?.(this.checkpoint);
+              },
+              retainResults: false,
+            });
+          } else {
+            // Bound direct map dispatch separately from ordinary provider
+            // residency. This prevents a blocked first chunk from launching
+            // another chunk ahead of a provider's admitted start rate, while
+            // preserving the wider resident-call capacity used by batched and
+            // high-latency providers.
+            const toolCallConcurrencyCeiling =
+              this.governor.policy.concurrency.toolCalls;
+            const shapedToolParallelism =
+              await this.resourceGovernor.suggestedDirectToolParallelism(
+                toolId,
                 toolCallConcurrencyCeiling,
-                Math.max(1, shapedToolParallelism),
               );
-              const dispatchResults = await dispatchBoundedSettled(
-                pendingRequests,
-                dispatchWidth,
-                async (request) => {
-                  // Circuit breaker: do not dispatch this provider call once a
-                  // persistence failure has occurred in this run.
-                  if (this.persistenceLatch.tripped) {
-                    this.persistenceLatch.preventedCallCount += 1;
-                    throw new RuntimePersistenceCircuitOpenError(
-                      this.persistenceLatch,
-                    );
-                  }
-                  let releaseToolSlot: () => void = () => undefined;
-                  try {
-                    const execution =
-                      await this.executeMappedToolCallThroughModule({
-                        request,
-                        dispatchToolId: toolId,
-                        dispatchPayload: request.input,
-                        // Always-fresh map calls intentionally have no
-                        // result cache. Their provider-operation identity is
-                        // a unique forced semantic request, never a cache key.
-                        resultReceiptKey:
-                          request.receiptKey ?? request.cacheKey,
-                        providerOperationKey:
-                          this.providerOperationKeyForQueuedToolCall(request),
-                        apiOptions: {
-                          beforeProviderCall: () =>
-                            pendingReceiptHeartbeat
-                              ? pendingReceiptHeartbeat.assertOwned()
-                              : this.assertRuntimeToolReceiptOwnership([
-                                  request,
-                                ]),
-                          playNodeScope:
-                            playNodeScopeForToolCallRequest(request),
-                          ...(request.receiptKey
-                            ? {
-                                durableCallReceiptKey: request.receiptKey,
-                                completedResultCache: true,
-                                executionAuthScopeDigest:
-                                  request.executionAuthScopeDigest,
-                                providerIdempotencyKey:
-                                  this.providerIdempotencyKeyForToolCall({
-                                    operationKey:
-                                      this.providerOperationKeyForQueuedToolCall(
-                                        request,
-                                      ),
-                                    force: request.force === true,
-                                    logicalCallId: request.logicalCallId,
-                                  }),
-                                ...this.providerForceRefreshOptionsForToolCall({
-                                  operationKey:
-                                    this.providerOperationKeyForQueuedToolCall(
-                                      request,
-                                    ),
-                                  force: request.force,
-                                  requiresExecutionFence:
-                                    request.requiresExecutionFence,
-                                  logicalCallId: request.logicalCallId,
+            const dispatchWidth = Math.min(
+              toolCallConcurrencyCeiling,
+              Math.max(1, shapedToolParallelism),
+            );
+            const dispatchResults = await dispatchBoundedSettled(
+              pendingRequests,
+              dispatchWidth,
+              async (request) => {
+                // Circuit breaker: do not dispatch this provider call once a
+                // persistence failure has occurred in this run.
+                if (this.persistenceLatch.tripped) {
+                  this.persistenceLatch.preventedCallCount += 1;
+                  throw new RuntimePersistenceCircuitOpenError(
+                    this.persistenceLatch,
+                  );
+                }
+                const providerOperationKey =
+                  this.providerInvocationKeyForToolCall({
+                    operationKey:
+                      this.providerOperationKeyForQueuedToolCall(request),
+                    logicalCallId: request.logicalCallId,
+                    force: request.force,
+                  });
+                let releaseToolSlot: () => void = () => undefined;
+                try {
+                  const execution =
+                    await this.executeMappedToolCallThroughModule({
+                      request,
+                      dispatchToolId: toolId,
+                      dispatchPayload: request.input,
+                      // Always-fresh map calls intentionally have no
+                      // result cache. Their provider-operation identity is
+                      // a unique forced semantic request, never a cache key.
+                      resultReceiptKey: request.receiptKey ?? request.cacheKey,
+                      providerOperationKey,
+                      apiOptions: {
+                        playNodeScope: playNodeScopeForToolCallRequest(request),
+                        executionAuthScopeDigest:
+                          request.executionAuthScopeDigest,
+                        providerIdempotencyKey: providerOperationKey,
+                        ...this.providerInvocationOptionsForToolCall({
+                          operationKey:
+                            this.providerOperationKeyForQueuedToolCall(request),
+                          requiresExecutionFence:
+                            request.requiresExecutionFence,
+                          logicalCallId: request.logicalCallId,
+                          force: request.force,
+                        }),
+                        ...(request.receiptKey
+                          ? {
+                              durableCallReceiptKey:
+                                this.toolTransportReceiptKey({
+                                  toolId,
+                                  providerOperationKey,
                                 }),
-                                receiptLeaseExpiresAt:
-                                  request.receiptLeaseExpiresAt,
-                                heartbeatReceipt: () =>
-                                  this.renewRuntimeToolReceiptOwnership([
-                                    request,
-                                  ]),
-                              }
-                            : {
-                                providerIdempotencyKey:
-                                  this.providerIdempotencyKeyForToolCall({
-                                    operationKey:
-                                      this.providerOperationKeyForQueuedToolCall(
+                              legacyProviderRetryIdentities: [
+                                {
+                                  transportReceiptKey: request.receiptKey,
+                                  providerOperationKey: request.force
+                                    ? providerOperationKey
+                                    : this.providerOperationKeyForQueuedToolCall(
                                         request,
                                       ),
-                                    force: true,
-                                    logicalCallId: request.logicalCallId,
-                                  }),
-                              }),
-                          timeoutMs: resolveRuntimeTimeoutMsForClaimedOwners([
-                            request,
-                          ]),
-                          retainToolSlot: (release) => {
-                            releaseToolSlot = release;
-                          },
+                                  ...(request.force &&
+                                  request.requiresExecutionFence !== true
+                                    ? {
+                                        forceRefreshIdentities: [
+                                          providerOperationKey,
+                                        ],
+                                      }
+                                    : {}),
+                                },
+                              ],
+                              completedResultCache: true,
+                            }
+                          : {}),
+                        timeoutMs: resolveRuntimeTimeoutMsForRequests([
+                          request,
+                        ]),
+                        retainToolSlot: (release) => {
+                          releaseToolSlot = release;
                         },
-                      });
-                    const result = await this.resolveToolCall(
-                      toolId,
-                      request,
-                      execution,
-                    );
-                    if (result != null) {
-                      successfulLiveStepCallIds.add(request.callId);
-                    }
-                    resolveLiveFollowers(request, result);
-                  } finally {
-                    releaseToolSlot();
+                      },
+                    });
+                  const result = await this.resolveToolCall(
+                    toolId,
+                    request,
+                    execution,
+                  );
+                  if (result != null) {
+                    successfulLiveStepCallIds.add(request.callId);
                   }
-                },
-              );
-              const failedEntries = dispatchResults.filter(
-                (entry) => entry.error !== undefined,
-              );
-              const failedSettlements = await Promise.allSettled(
-                failedEntries.map((entry) =>
-                  rejectWithLiveFollowers(entry.job, entry.error),
-                ),
-              );
-              const failedRejection = failedSettlements.find(
-                (settlement): settlement is PromiseRejectedResult =>
-                  settlement.status === 'rejected',
-              );
-              if (failedRejection) throw failedRejection.reason;
-              recordToolStep(pendingRequests);
-              this.#options.onBatchComplete?.(this.checkpoint);
-            }
-          }
-        } catch (reason) {
-          providerFailure = { reason };
-          durableExistingRunningAbort.abort(reason);
-        } finally {
-          pendingReceiptHeartbeat?.stop();
-        }
-        const pendingReceiptLeaseLost = pendingReceiptHeartbeat?.leaseLost();
-        if (pendingReceiptLeaseLost && providerFailure === null) {
-          providerFailure = { reason: pendingReceiptLeaseLost };
-          durableExistingRunningAbort.abort(pendingReceiptLeaseLost);
-        }
-        const durableExistingRunningSettlement =
-          durableExistingRunningState.settlement;
-        if (durableExistingRunningSettlement) {
-          const settlement = await durableExistingRunningSettlement;
-          if (settlement.status === 'rejected' && providerFailure === null) {
-            providerFailure = { reason: settlement.reason };
+                } finally {
+                  releaseToolSlot();
+                }
+              },
+            );
+            const failedEntries = dispatchResults.filter(
+              (entry) => entry.error !== undefined,
+            );
+            const failedSettlements = await Promise.allSettled(
+              failedEntries.map((entry) => rejectCall(entry.job, entry.error)),
+            );
+            const failedRejection = failedSettlements.find(
+              (settlement): settlement is PromiseRejectedResult =>
+                settlement.status === 'rejected',
+            );
+            if (failedRejection) throw failedRejection.reason;
+            recordToolStep(pendingRequests);
+            this.#options.onBatchComplete?.(this.checkpoint);
           }
         }
-        if (providerFailure) throw providerFailure.reason;
       }),
     );
     const rejected = toolSettlements.find(
@@ -18323,24 +16873,18 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
     )(ctx, input);
   }
 
-  private providerIdempotencyKeyForToolCall(input: {
+  private providerInvocationKeyForToolCall(input: {
     operationKey: string;
-    force?: boolean;
     logicalCallId?: string;
+    force?: boolean;
   }): string {
-    let fallbackAttemptId: string | null = null;
-    if (input.force === true) {
-      if (!input.logicalCallId) {
-        throw new Error(
-          'Forced tool execution requires a stable logical call identity.',
-        );
-      }
-      fallbackAttemptId = `${this.currentRunId}:${input.logicalCallId}`;
+    if (!input.logicalCallId) {
+      throw new Error('Tool execution requires a stable invocation identity.');
     }
     return buildProviderOperationIdempotencyKey({
       operationKey: input.operationKey,
-      force: input.force,
-      fallbackAttemptId,
+      force: true,
+      fallbackAttemptId: `${this.currentRunId}:${input.logicalCallId}${input.force === true ? '' : ':cache-miss'}`,
     });
   }
 
@@ -18986,7 +17530,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
           const ambiguousTransportReplayAllowed =
             readOnlyQuery || retrySafeTransientHttp;
           const invocationOrgId = this.#options.orgId?.trim() ?? '';
-          const durableCallReceiptKey = uncachedAsyncLifecycleCall
+          let durableCallReceiptKey = uncachedAsyncLifecycleCall
             ? null
             : options?.durableCallReceiptKey?.trim() ||
               (usesDurableInvocationFence && invocationOrgId
@@ -19004,9 +17548,57 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
             this.#options.durableBoundaries && durableCallReceiptKey
               ? stableDigest(`provider-retry:${durableCallReceiptKey}`)
               : null;
-          const savedProviderRetryCursor = providerRetryCursorKey
+          let savedProviderRetryCursor = providerRetryCursorKey
             ? this.checkpoint.providerRetryCursors?.[providerRetryCursorKey]
             : undefined;
+          if (providerRetryCursorKey && !savedProviderRetryCursor) {
+            // Native calls can move from the outgoing fallback into the Module.
+            // Probe only exact owner-supplied checkpoint identities; never wait
+            // on another invocation or derive a fence from customer strings.
+            for (const legacy of options?.legacyProviderRetryIdentities ?? []) {
+              const legacyCursorKey = stableDigest(
+                `provider-retry:${legacy.transportReceiptKey}`,
+              );
+              const cursor =
+                this.checkpoint.providerRetryCursors?.[legacyCursorKey];
+              if (!cursor) continue;
+              // Consume synchronously before any await so a sibling cannot
+              // inherit the same outgoing invocation.
+              delete this.checkpoint.providerRetryCursors![legacyCursorKey];
+              savedProviderRetryCursor = {
+                ...cursor,
+                legacyProviderOperationKey:
+                  cursor.legacyProviderOperationKey ??
+                  legacy.providerOperationKey,
+                legacyTransportReceiptKey:
+                  cursor.legacyTransportReceiptKey ??
+                  legacy.transportReceiptKey,
+                ...(legacy.forceRefreshIdentities?.length
+                  ? {
+                      legacyProviderOperationForceRefreshIdentities:
+                        cursor.legacyProviderOperationForceRefreshIdentities ??
+                        legacy.forceRefreshIdentities,
+                    }
+                  : {}),
+              };
+              this.checkpoint.providerRetryCursors![providerRetryCursorKey] =
+                savedProviderRetryCursor;
+              break;
+            }
+          }
+          // The checkpoint index stays unique to this invocation. Its wire
+          // identities must still name the prior gateway outcome so that a
+          // qualified 429 retry can be attested after any further suspension.
+          const legacyProviderOperationKey =
+            savedProviderRetryCursor?.legacyProviderOperationKey;
+          if (savedProviderRetryCursor?.legacyTransportReceiptKey) {
+            durableCallReceiptKey =
+              savedProviderRetryCursor.legacyTransportReceiptKey;
+          }
+          const providerOperationForceRefreshIdentities =
+            legacyProviderOperationKey
+              ? savedProviderRetryCursor?.legacyProviderOperationForceRefreshIdentities
+              : options?.providerOperationForceRefreshIdentities;
           const executionRequestNonce = crypto.randomUUID();
           // Transport ambiguity must retain the billing identity. An ordinary
           // (unfenced) call advances it only after a definite provider-owned
@@ -19020,7 +17612,9 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
           const providerIdempotencyReceiptKey =
             options?.providerIdempotencyReceiptKey?.trim() || null;
           const providerExecutionFenceKey = requiresExecutionFence
-            ? options?.providerIdempotencyKey?.trim() || null
+            ? legacyProviderOperationKey ||
+              options?.providerIdempotencyKey?.trim() ||
+              null
             : null;
           if (requiresExecutionFence && !providerExecutionFenceKey) {
             throw new Error(
@@ -19029,14 +17623,15 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
           }
           const canonicalOperationActionVersion =
             providerExecutionFenceKey ||
-            options?.providerOperationForceRefreshIdentities?.length
+            providerOperationForceRefreshIdentities?.length
               ? (
                   await this.#options.getToolActionCacheVersion?.(toolId)
                 )?.trim() || null
               : null;
           const canonicalOperation =
+            !uncachedAsyncLifecycleCall &&
             (providerExecutionFenceKey ||
-              options?.providerOperationForceRefreshIdentities?.length) &&
+              providerOperationForceRefreshIdentities?.length) &&
             canonicalOperationActionVersion
               ? {
                   version: 1,
@@ -19046,10 +17641,10 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
                   output_intent: options?.completedResultCache
                     ? 'dataset'
                     : 'value',
-                  ...(options?.providerOperationForceRefreshIdentities?.length
+                  ...(providerOperationForceRefreshIdentities?.length
                     ? {
                         force_refresh_identities:
-                          options.providerOperationForceRefreshIdentities,
+                          providerOperationForceRefreshIdentities,
                       }
                     : {}),
                 }
@@ -19183,9 +17778,16 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
           };
           const persistProviderRetryCursor = (retryFrom: number) => {
             if (!providerRetryCursorKey) return;
-            const cursor = {
+            const cursor: ProviderRetryCursor = {
+              ...savedProviderRetryCursor,
               invocationAttempt: retryFrom + 1,
               retryFromInvocationAttempt: retryFrom,
+              ...(legacyProviderOperationKey
+                ? {
+                    legacyProviderOperationKey,
+                    legacyTransportReceiptKey: durableCallReceiptKey!,
+                  }
+                : {}),
             };
             this.checkpoint.providerRetryCursors ??= {};
             this.checkpoint.providerRetryCursors[providerRetryCursorKey] =