deepline 0.1.227 → 0.1.229

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

@@ -42,17 +42,7 @@ import {
   mapRowOutcomeRuntimeFields,
   resolveMapRowOutcomeKey,
 } from './map-row-outcome';
-import { buildChildRunId } from './child-run-id';
-import type { PlayCallGovernanceSnapshot } from './scheduler-backend';
-import {
-  ABSURD_RELEASE_OVERRIDE_HEADER,
-  RUNTIME_SCHEDULER_SCHEMA_OVERRIDE_HEADER,
-  SYNTHETIC_RUN_HEADER,
-} from './coordinator-headers';
-import {
-  PLAY_RUNTIME_API_COMPAT_PATH,
-  PLAY_RUNTIME_API_CURRENT_PATH,
-} from './runtime-api-paths';
+import { PLAY_RUNTIME_API_COMPAT_PATH } from './runtime-api-paths';
 import {
   createRootRunExecutionScope,
   deriveChildRunExecutionScope,
@@ -108,6 +98,10 @@ import {
   ToolExecuteAuthScopeChangedError,
 } from './tool-execute-retry-policy';
 import { ToolHttpError } from './tool-http-errors';
+import {
+  describeTransportError,
+  transportGatewayOriginForDiagnostic,
+} from './transport-error-diagnostics';
 import {
   buildDurableCtxCallCacheKey,
   buildDurableRunPlayInvocationScope,
@@ -241,8 +235,8 @@ import {
 } from './step-program-dataset-builder';
 import { readRuntimeSheetDatasetRows } from './runtime-api';
 import {
+  ctxRunPlayInlineOnlyMessage,
   resolveChildExecutionStrategy,
-  inlineChildScheduledInRowMessage,
 } from './child-execution-strategy';
 
 type ResolvedPlayExecutor = (
@@ -263,6 +257,11 @@ const rowContext = new AsyncLocalStorage<{
   tableNamespace?: string;
   rowKey?: string;
   mapScope?: MapExecutionScope;
+  /**
+   * Per-resolver inline-child fan-width guard. This stays in the async row
+   * scope, so it becomes collectible as soon as the resolver settles.
+   */
+  inlineChildInvocationNamespaces?: Set<string>;
 }>();
 type InlineCompositionStore = {
   context: PlayContextImpl;
@@ -303,19 +302,11 @@ const FETCH_TRANSPORT_RETRY_DELAY_MS = 100;
 // provider 502; require both the branded page and our development tunnel host.
 const DEEPLINE_DEVELOPER_TUNNEL_ORIGIN_502_PATTERN =
   /\bdeeplinedeveloper\.com\s*\|\s*502\s*:\s*bad gateway\b/i;
-const CHILD_PLAY_LAUNCH_WRITE_CONFLICT_RETRY_DELAYS_MS = [
-  50, 100, 200, 400, 800,
-] as const;
-const CHILD_PLAY_LAUNCH_ADMISSION_RETRY_DELAYS_MS = [
-  250, 500, 1_000, 2_000, 4_000, 8_000, 8_000, 8_000, 8_000, 8_000, 8_000,
-  8_000, 8_000, 8_000, 8_000,
-] as const;
 const NODE_RUNTIME_MAP_VISIBILITY_MAX_ATTEMPTS = 100;
 const NODE_RUNTIME_MAP_VISIBILITY_RETRY_MS = 25;
 // Per-row sanity cap on distinct inline child invocations. `maxPlayCallDepth`
-// (governor) already bounds nesting; this bounds fan-WIDTH from a single row so
-// a resolver that loops `ctx.runPlay` unbounded fails loudly instead of leaking
-// composition namespaces. Well above any legitimate authored per-row fan-out.
+// (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.
 const MAX_INLINE_CHILD_INVOCATIONS_PER_ROW = 512;
 // Bound the retained failure detail carried in parent aggregates so a fully
 // failing large map cannot grow the progress event without limit.
@@ -350,44 +341,6 @@ export function chunkArrayForReceiptRequest<T>(items: readonly T[]): T[][] {
 type SafeFetchModule = typeof import('@shared_libs/security/safe-fetch');
 let safeFetchModule: Promise<SafeFetchModule> | null = null;
 
-function sleepTransientRuntimeMs(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-function isConvexWriteConflictMessage(message: string): boolean {
-  return (
-    message.includes('OptimisticConcurrencyControlFailure') ||
-    /changed while this mutation was being run/i.test(message) ||
-    /write conflict/i.test(message)
-  );
-}
-
-function isChildPlayLaunchAdmissionMessage(message: string): boolean {
-  return /too many play runs (?:are )?(?:starting|active)/i.test(message);
-}
-
-function childPlayLaunchRetryDelayMs(input: {
-  status: number;
-  message: string;
-  attempt: number;
-}): number | null {
-  if (
-    input.status === 429 &&
-    isChildPlayLaunchAdmissionMessage(input.message)
-  ) {
-    return CHILD_PLAY_LAUNCH_ADMISSION_RETRY_DELAYS_MS[input.attempt] ?? null;
-  }
-  if (
-    ![409, 429, 500, 502, 503, 504].includes(input.status) ||
-    !isConvexWriteConflictMessage(input.message)
-  ) {
-    return null;
-  }
-  return (
-    CHILD_PLAY_LAUNCH_WRITE_CONFLICT_RETRY_DELAYS_MS[input.attempt] ?? null
-  );
-}
-
 export async function waitForNodeRuntimeMapRowsVisible(input: {
   mapName: string;
   tableNamespace: string;
@@ -1237,13 +1190,6 @@ export class PlayContextImpl {
     eventKey: string;
     timeoutMs: number;
   }> = [];
-  private pendingChildPlayBoundaries: Array<{
-    boundaryId: string;
-    childRunId: string;
-    childPlayName: string;
-  }> = [];
-  private activeScheduledChildPlayCalls = 0;
-  private scheduledChildPlayQuiescenceWaiters: Array<() => void> = [];
   private processedRowCount = 0;
   private sleepBoundaryIndex = 0;
   private fetchCallIndex = 0;
@@ -1251,19 +1197,6 @@ export class PlayContextImpl {
     createSecretRedactionContext();
   private mapInvocationIndex = 0;
   private readonly stepCallIndexByKey = new Map<string, number>();
-  /**
-   * Registry of distinct inline child invocation namespaces seen by this
-   * context. Inline child composition is a function call, not a run; each
-   * invocation's namespace (`child:<playName>#<callKey>[@<rowScope>]`) scopes
-   * its receipts under the parent run. See ADR 0013.
-   */
-  private readonly inlineChildInvocationOrdinals = new Map<string, number>();
-  /**
-   * Distinct inline child invocations per row scope (top-level counts as one
-   * scope). Backs the per-row fan-width sanity cap so a resolver looping
-   * `ctx.runPlay` unbounded fails loudly instead of leaking namespaces.
-   */
-  private readonly inlineChildInvocationsPerRow = new Map<string, number>();
   /**
    * Parent-level inline-child aggregates. Maintained only by the single-writer
    * progress path (never per child) so concurrent fan-out cannot contend. See
@@ -1474,6 +1407,15 @@ export class PlayContextImpl {
     return active?.context === this ? active : null;
   }
 
+  /** Enforce the scalar inline-child contract at dynamic API boundaries. */
+  private assertInlineChildContract(
+    reason: 'dataset_child' | 'suspending_child',
+  ): void {
+    const composition = this.activeInlineComposition;
+    if (!composition) return;
+    throw new Error(ctxRunPlayInlineOnlyMessage(composition.playName, reason));
+  }
+
   private get currentExecutionScope(): RunExecutionScope {
     return this.activeInlineComposition?.executionScope ?? this.executionScope;
   }
@@ -1495,100 +1437,9 @@ export class PlayContextImpl {
     return active ? active.staticPipeline : this.#options.staticPipeline;
   }
 
-  private shouldLaunchChildPlaysThroughScheduler(): boolean {
-    return (
-      this.#options.requireSharedRateState === true &&
-      this.#options.durableBoundaries === true
-    );
-  }
-
-  private childPlayBoundaryId(childRunId: string): string {
-    return this.durableBoundaryId(`runPlay:${childRunId}`);
-  }
-
-  private recordPendingChildPlayBoundary(input: {
-    boundaryId: string;
-    childRunId: string;
-    childPlayName: string;
-  }): void {
-    this.pendingChildPlayBoundaries.push(input);
-  }
-
-  private beginScheduledChildPlayCall(): { release: () => void } {
-    this.activeScheduledChildPlayCalls += 1;
-    let released = false;
-    return {
-      release: () => {
-        if (released) return;
-        released = true;
-        this.activeScheduledChildPlayCalls = Math.max(
-          0,
-          this.activeScheduledChildPlayCalls - 1,
-        );
-        if (this.activeScheduledChildPlayCalls !== 0) return;
-        for (const resolve of this.scheduledChildPlayQuiescenceWaiters.splice(
-          0,
-        )) {
-          resolve();
-        }
-      },
-    };
-  }
-
-  private async waitForScheduledChildPlayQuiescence(): Promise<void> {
-    if (this.activeScheduledChildPlayCalls === 0) return;
-    await new Promise<void>((resolve) => {
-      this.scheduledChildPlayQuiescenceWaiters.push(resolve);
-    });
-  }
-
-  private consumePendingChildPlaySuspension(): PlayExecutionSuspension | null {
-    if (this.pendingChildPlayBoundaries.length === 0) return null;
-    const boundaries = [
-      ...new Map(
-        this.pendingChildPlayBoundaries.map((boundary) => [
-          boundary.boundaryId,
-          boundary,
-        ]),
-      ).values(),
-    ];
-    this.pendingChildPlayBoundaries = [];
-    if (boundaries.length === 1) {
-      const boundary = boundaries[0]!;
-      return {
-        kind: 'child_play',
-        boundaryId: boundary.boundaryId,
-        childRunId: boundary.childRunId,
-        childPlayName: boundary.childPlayName,
-      };
-    }
-    return {
-      kind: 'child_play_batch',
-      boundaries,
-    };
-  }
-
-  private childPlayBoundaryOutput<TOutput>(input: {
-    boundaryId: string;
-    childRunId: string;
-    childPlayName: string;
-  }): { found: true; output: TOutput } | { found: false } {
-    const existing = this.checkpoint.resolvedBoundaries?.[input.boundaryId];
-    if (!existing || existing.kind !== 'child_play') return { found: false };
-    if (existing.childRunId !== input.childRunId) return { found: false };
-    if (existing.status === 'completed') {
-      return { found: true, output: existing.output as TOutput };
-    }
-    const message =
-      typeof existing.error === 'string' && existing.error.trim()
-        ? existing.error.trim()
-        : `Child play ${input.childPlayName} (${input.childRunId}) ${existing.status}.`;
-    throw new Error(message);
-  }
-
   private recordPlayCallStep(input: {
     playId: string;
-    execution?: 'inline' | 'child-workflow';
+    execution?: 'inline';
     description?: string | null;
     nestedSteps?: PlayStep[];
   }): void {
@@ -1612,186 +1463,6 @@ export class PlayContextImpl {
     );
   }
 
-  private async runtimeApiHeaders(): Promise<Record<string, string>> {
-    if (!this.#options.executorToken?.trim()) {
-      throw new Error(
-        'ctx.runPlay scheduled child launch requires an executor token.',
-      );
-    }
-    return {
-      Authorization: `Bearer ${this.#options.executorToken.trim()}`,
-      'Content-Type': 'application/json',
-      ...(this.#options.runtimeSchedulerSchema?.trim()
-        ? {
-            [RUNTIME_SCHEDULER_SCHEMA_OVERRIDE_HEADER]:
-              this.#options.runtimeSchedulerSchema.trim(),
-            [SYNTHETIC_RUN_HEADER]: '1',
-          }
-        : {}),
-      // Defense-in-depth: pin the child to the parent worker's release lane so
-      // a child always finishes on the release that launched its parent, even
-      // if the resolver default (schema-derived) would drift. The run route
-      // honors this only for internal ctx.runPlay child launches.
-      ...(this.#options.absurdReleaseId?.trim()
-        ? {
-            [ABSURD_RELEASE_OVERRIDE_HEADER]:
-              this.#options.absurdReleaseId.trim(),
-          }
-        : {}),
-      ...(await this.vercelProtectionHeaders()),
-    };
-  }
-
-  private runtimeApiBaseUrl(): string {
-    const baseUrl = this.#options.baseUrl?.trim();
-    if (!baseUrl) {
-      throw new Error('ctx.runPlay scheduled child launch requires baseUrl.');
-    }
-    return baseUrl.replace(/\/$/, '');
-  }
-
-  private async launchScheduledChildPlay(input: {
-    key: string;
-    childRunId: string;
-    childPlayName: string;
-    childGovernance: GovernanceSnapshot;
-    childInput: Record<string, unknown>;
-    description?: string | null;
-  }): Promise<void> {
-    const parentGovernance = this.currentGovernance;
-    const parentPlayName =
-      parentGovernance.currentPlayId ||
-      this.currentPlayName ||
-      this.#options.playId ||
-      'anonymous-play';
-    const governance: PlayCallGovernanceSnapshot = {
-      rootRunId: parentGovernance.rootRunId,
-      parentRunId: parentGovernance.currentRunId,
-      parentPlayName,
-      key: input.key,
-      ancestryPlayIds: [...parentGovernance.ancestryPlayIds],
-      callDepth: input.childGovernance.callDepth,
-      playCallCount: input.childGovernance.playCallCount,
-      toolCallCount: input.childGovernance.toolCallCount,
-      retryCount: input.childGovernance.retryCount,
-      descendantCount: input.childGovernance.descendantCount,
-      waterfallStepExecutions: input.childGovernance.waterfallStepExecutions,
-    };
-    const requestBody = JSON.stringify({
-      name: input.childPlayName,
-      workflowId: input.childRunId,
-      input: input.childInput,
-      // Inherit the parent's scheduler profile so an `absurd` parent launches
-      // its child on the same scheduler. Absent threading defaults to absurd.
-      profile: this.#options.childRunProfile?.trim() || 'absurd',
-      waitForCompletionMs: 0,
-      internalRunPlay: {
-        ...governance,
-        description: input.description ?? null,
-      },
-    });
-    for (let attempt = 0; ; attempt += 1) {
-      const response = await fetch(
-        `${this.runtimeApiBaseUrl()}/api/v2/plays/run`,
-        {
-          method: 'POST',
-          headers: await this.runtimeApiHeaders(),
-          body: requestBody,
-        },
-      );
-      if (response.ok) {
-        if (attempt > 0) {
-          this.log(
-            `ctx.runPlay(${input.key}): child launch recovered after ${attempt} retry(s)`,
-          );
-        }
-        return;
-      }
-      const body = (await response.json().catch(() => null)) as {
-        error?: unknown;
-      } | null;
-      const message =
-        typeof body?.error === 'string' && body.error.trim()
-          ? body.error.trim()
-          : response.statusText;
-      const retryDelayMs = childPlayLaunchRetryDelayMs({
-        status: response.status,
-        message,
-        attempt,
-      });
-      if (retryDelayMs === null) {
-        throw new Error(
-          `ctx.runPlay(${input.key}) failed to launch child play "${input.childPlayName}": ${message} (status ${response.status}).`,
-        );
-      }
-      const retryReason =
-        response.status === 429 && isChildPlayLaunchAdmissionMessage(message)
-          ? 'start admission backpressure'
-          : 'transient write conflict';
-      this.log(
-        `ctx.runPlay(${input.key}): retrying child launch after ${retryReason} (attempt ${attempt + 1})`,
-      );
-      await sleepTransientRuntimeMs(retryDelayMs);
-    }
-  }
-
-  private async readScheduledChildTerminal<TOutput>(input: {
-    childRunId: string;
-    childPlayName: string;
-  }): Promise<
-    | { status: 'completed'; output: TOutput }
-    | { status: 'failed' | 'cancelled'; error: string }
-    | null
-  > {
-    const response = await fetch(
-      `${this.runtimeApiBaseUrl()}${PLAY_RUNTIME_API_COMPAT_PATH}`,
-      {
-        method: 'POST',
-        headers: await this.runtimeApiHeaders(),
-        body: JSON.stringify({
-          action: 'read_child_run_terminal_snapshot',
-          parentRunId: this.currentGovernance.currentRunId,
-          childRunId: input.childRunId,
-          childPlayName: input.childPlayName,
-        }),
-      },
-    );
-    const body = (await response.json().catch(() => null)) as {
-      state?: {
-        data?: {
-          status?: unknown;
-          result?: unknown;
-          error?: unknown;
-        };
-      };
-      error?: unknown;
-    } | null;
-    if (!response.ok) {
-      const message =
-        typeof body?.error === 'string' && body.error.trim()
-          ? body.error.trim()
-          : response.statusText;
-      throw new Error(
-        `ctx.runPlay failed to read child terminal snapshot for "${input.childPlayName}": ${message} (status ${response.status}).`,
-      );
-    }
-    const data = body?.state?.data;
-    const status = String(data?.status ?? '').toLowerCase();
-    if (status === 'completed') {
-      return { status, output: data?.result as TOutput };
-    }
-    if (status === 'failed' || status === 'cancelled') {
-      return {
-        status,
-        error:
-          typeof data?.error === 'string' && data.error.trim()
-            ? data.error.trim()
-            : `Child play ${input.childPlayName} (${input.childRunId}) ${status}.`,
-      };
-    }
-    return null;
-  }
-
   private emitScopedRowUpdate(
     key: string | null,
     tableNamespace: string | null,
@@ -3699,6 +3370,7 @@ export class PlayContextImpl {
     path: string,
     _options?: CsvOptions,
   ): Promise<PlayDataset<Record<string, unknown>>> {
+    this.assertInlineChildContract('dataset_child');
     void _options;
     // In cloud mode, CSV data is passed in — path is just a label
     // The activity loads the actual data before creating the ctx
@@ -3727,6 +3399,7 @@ export class PlayContextImpl {
     input?: MapFieldDefinition<T, TColumns> | RuntimeStepProgram,
     options?: DatasetOptions<T>,
   ): RuntimeDatasetBuilder<T> | Promise<PlayDataset<Record<string, unknown>>> {
+    this.assertInlineChildContract('dataset_child');
     if (rowContext.getStore()) {
       throw new Error(
         'Nested ctx.dataset() is not supported. Flatten your fields into one dataset, or keep custom per-row logic inside a single column.',
@@ -6315,13 +5988,6 @@ export class PlayContextImpl {
           this.toolCallQueue.length === 0 &&
           inFlightToolExecutions.size === 0
         ) {
-          if (!this.activeDatasetStep) {
-            const childPlaySuspension =
-              this.consumePendingChildPlaySuspension();
-            if (childPlaySuspension) {
-              throw new PlayExecutionSuspendedError(childPlaySuspension);
-            }
-          }
           break;
         }
 
@@ -6723,6 +6389,7 @@ export class PlayContextImpl {
     input: Record<string, unknown>,
     handler: IntegrationEventWaitHandler,
   ): Promise<unknown> {
+    this.assertInlineChildContract('suspending_child');
     if (!this.#options.durableBoundaries) {
       throw new Error(`${toolId} requires durable play boundaries.`);
     }
@@ -6841,328 +6508,136 @@ export class PlayContextImpl {
     if (!resolvedName.trim()) {
       throw new Error('ctx.runPlay(...) requires a resolvable play name.');
     }
-    let scheduledChildPlayCall: { release(): void } | null = null;
+    if (!this.#options.resolvePlay) {
+      throw new Error(
+        'ctx.runPlay(...) is unavailable because no play resolver was configured.',
+      );
+    }
+    const resolvedPlay = await this.#options.resolvePlay(resolvedName);
+    if (!resolvedPlay) {
+      throw new Error(
+        `Unable to resolve play "${resolvedName}" for ctx.runPlay(...).`,
+      );
+    }
+    const childExecutionDecision = resolveChildExecutionStrategy({
+      pipeline: resolvedPlay.staticPipeline,
+      timeoutMs: options?.timeoutMs,
+      hasExplicitTimeout:
+        options != null && Object.hasOwn(options, 'timeoutMs'),
+      execution: options?.execution,
+      childPlayName: resolvedName,
+    });
+    this.log(
+      `ctx.runPlay(${normalizedKey}): ${childExecutionDecision.strategy} (${childExecutionDecision.reason})`,
+    );
 
-    try {
-      if (!this.#options.resolvePlay) {
-        throw new Error(
-          'ctx.runPlay(...) is unavailable because no play resolver was configured.',
-        );
-      }
-      const resolvePlay = this.#options.resolvePlay;
-      const resolvedPlay = await resolvePlay(resolvedName);
-      if (!resolvedPlay) {
-        throw new Error(
-          `Unable to resolve play "${resolvedName}" for ctx.runPlay(...).`,
-        );
-      }
-      const childExecutionDecision = resolveChildExecutionStrategy({
-        pipeline: resolvedPlay.staticPipeline,
-        execution: options?.execution,
+    const compositionNamespace = this.inlineChildCompositionNamespace(
+      resolvedName,
+      normalizedKey,
+    );
+    const inlineChildGovernor =
+      await this.currentExecutionGovernor.forkInlineChild({
         childPlayName: resolvedName,
+        childRunId: compositionNamespace,
       });
-      const launchThroughScheduler =
-        this.shouldLaunchChildPlaysThroughScheduler() &&
-        childExecutionDecision.strategy === 'scheduled';
-      scheduledChildPlayCall = launchThroughScheduler
-        ? this.beginScheduledChildPlayCall()
-        : null;
-      this.log(
-        `ctx.runPlay(${normalizedKey}): ${childExecutionDecision.strategy} (${childExecutionDecision.reason})`,
-      );
-      const runPlayRowScope = rowContext.getStore();
-      // Runtime enforcement of the row-scoped-scheduled-child rule for children
-      // whose name is only known at runtime (static preflight cannot see them).
-      // A scheduling-required child fanned out per row is the 100,000-run-doc
-      // failure mode the inline-child cutover removes. Fail on the FIRST row,
-      // loud, with the SAME message the static preflight emits. See ADR 0013.
-      //
-      // Mirrors the static check's proof standard: reject when the child's
-      // resolved contract PROVES it needs scheduling (dataset/csv, event-wait,
-      // explicit timeout), or when this call would actually launch a durable
-      // scheduled child run per row. A missing static contract alone is not
-      // proof — in-process fallback runtimes legitimately run contract-less
-      // scalar children inline.
-      const provablySchedulingRequired =
-        childExecutionDecision.strategy === 'scheduled' &&
-        childExecutionDecision.reason !== 'missing_static_contract';
-      if (
-        runPlayRowScope &&
-        (provablySchedulingRequired || launchThroughScheduler)
-      ) {
-        throw new Error(
-          inlineChildScheduledInRowMessage(
-            resolvedName,
-            runPlayRowScope.tableNamespace ??
-              runPlayRowScope.fieldName ??
-              'dataset',
-          ),
-        );
+    const rowStore = rowContext.getStore();
+    const producer = {
+      kind: 'play' as const,
+      id: normalizedKey,
+      playId: resolvedName,
+      displayName: displayNameFromProducerId(resolvedName),
+      runId: compositionNamespace,
+    };
+    try {
+      if (rowStore) {
+        this.emitScopedFieldMetaUpdate({
+          rowId: rowStore.rowId,
+          key: rowStore.rowKey ?? null,
+          tableNamespace: rowStore.tableNamespace ?? null,
+          fieldName: rowStore.fieldName,
+          status: 'running',
+          rowStatus: 'running',
+          stage: resolvedName,
+          provider: 'deepline_native',
+          error: null,
+          producer,
+          dataPatch: {},
+        });
       }
-      const runPlayInvocationScope = buildDurableRunPlayInvocationScope({
-        childPlayName: resolvedName,
-        input,
-        rowScope: runPlayRowScope
-          ? {
-              fieldName: runPlayRowScope.fieldName,
-              rowKey: runPlayRowScope.rowKey ?? null,
-              tableNamespace: runPlayRowScope.tableNamespace ?? null,
-            }
-          : null,
-      });
-
-      const executePlayCall = async (): Promise<TOutput> => {
-        // Scheduled children reserve the parent's durable play/descendant
-        // budgets. Inline scalar children are function composition: their
-        // Governor view changes only local lineage for recursion/depth checks
-        // and delegates tool admission, pacing, and tool budgets to the parent.
-        //
-        // The SCHEDULED substrate still allocates a durable child run id (through
-        // the shared canonical builder so in-process and the workers_edge
-        // coordinator produce the same FORMAT `play/<slug>/run/child-<digest>`).
-        // INLINE scalar children are pure function composition (ADR 0013): they
-        // carry NO durable run identity — no child run id, no playRuns doc, no
-        // settlement. Their only identity is a replay-stable, call-site scoped
-        // composition namespace (`child:<playName>#<ordinal>`) used to scope tool
-        // receipts under the PARENT run. See child-composition-namespace below.
-        const parentGovernor = this.currentExecutionGovernor;
-        const inlineChildGovernor = launchThroughScheduler
-          ? null
-          : await parentGovernor.forkInlineChild({
-              childPlayName: resolvedName,
-              childRunId: this.inlineChildCompositionNamespace(
-                resolvedName,
-                normalizedKey,
-              ),
-            });
-        const childGovernance = launchThroughScheduler
-          ? await parentGovernor.forkChild({
-              childPlayName: resolvedName,
-              childRunId: buildChildRunId({
-                childPlayName: resolvedName,
-                parentRunId: this.currentRunId,
-                parentPlayName: this.#options.playName,
-                key: normalizedKey,
-                runPlaySemanticKey: runPlayInvocationScope,
-                input,
-                graphHash: null,
-              }),
-            })
-          : inlineChildGovernor!.snapshot();
-        const childPlaySlot = launchThroughScheduler
-          ? await parentGovernor.acquireChildSubmitSlot()
-          : null;
-        const rowStore = rowContext.getStore();
-        const producer = {
-          kind: 'play' as const,
-          id: normalizedKey,
+      // Inline composition has no child run, launch request, terminal poll, or
+      // scheduler slot. It shares the caller's execution and tool governors.
+      const childExecutionScope = deriveChildRunExecutionScope(
+        this.currentExecutionScope,
+        {
+          placement: 'inline',
+          runId: compositionNamespace,
           playId: resolvedName,
-          displayName: displayNameFromProducerId(resolvedName),
-          // For scheduled children this is the durable child run id; for inline
-          // children it is the composition namespace (`child:<playName>#<ord>`).
-          runId: childGovernance.currentRunId,
-        };
-        try {
-          if (rowStore) {
-            this.emitScopedFieldMetaUpdate({
-              rowId: rowStore.rowId,
-              key: rowStore.rowKey ?? null,
-              tableNamespace: rowStore.tableNamespace ?? null,
-              fieldName: rowStore.fieldName,
-              status: 'running',
-              rowStatus: 'running',
-              stage: resolvedName,
-              provider: 'deepline_native',
-              error: null,
-              producer,
-              dataPatch: {},
-            });
-          }
-          if (launchThroughScheduler) {
-            const boundaryId = this.childPlayBoundaryId(
-              childGovernance.currentRunId,
-            );
-            const checkpointResult = this.childPlayBoundaryOutput<TOutput>({
-              boundaryId,
-              childRunId: childGovernance.currentRunId,
-              childPlayName: resolvedName,
-            });
-            if (checkpointResult.found) {
-              if (rowStore) {
-                this.emitScopedFieldMetaUpdate({
-                  rowId: rowStore.rowId,
-                  key: rowStore.rowKey ?? null,
-                  tableNamespace: rowStore.tableNamespace ?? null,
-                  fieldName: rowStore.fieldName,
-                  status: 'completed',
-                  rowStatus: 'running',
-                  stage: resolvedName,
-                  provider: 'deepline_native',
-                  error: null,
-                  producer,
-                  dataPatch: {},
-                });
-              }
-              this.recordPlayCallStep({
-                playId: resolvedName,
-                execution: options?.execution,
-                description: options?.description,
-              });
-              return checkpointResult.output;
-            }
-
-            await this.launchScheduledChildPlay({
-              key: normalizedKey,
-              childRunId: childGovernance.currentRunId,
-              childPlayName: resolvedName,
-              childGovernance,
-              childInput: input,
-              description: options?.description ?? null,
-            });
-            childPlaySlot?.release();
-            const terminal = await this.readScheduledChildTerminal<TOutput>({
-              childRunId: childGovernance.currentRunId,
-              childPlayName: resolvedName,
-            });
-            if (terminal?.status === 'completed') {
-              this.checkpoint.resolvedBoundaries = {
-                ...(this.checkpoint.resolvedBoundaries ?? {}),
-                [boundaryId]: {
-                  kind: 'child_play',
-                  childRunId: childGovernance.currentRunId,
-                  childPlayName: resolvedName,
-                  status: 'completed',
-                  output: terminal.output,
-                  completedAt: Date.now(),
-                },
-              };
-              if (rowStore) {
-                this.emitScopedFieldMetaUpdate({
-                  rowId: rowStore.rowId,
-                  key: rowStore.rowKey ?? null,
-                  tableNamespace: rowStore.tableNamespace ?? null,
-                  fieldName: rowStore.fieldName,
-                  status: 'completed',
-                  rowStatus: 'running',
-                  stage: resolvedName,
-                  provider: 'deepline_native',
-                  error: null,
-                  producer,
-                  dataPatch: {},
-                });
-              }
-              this.recordPlayCallStep({
-                playId: resolvedName,
-                execution: options?.execution,
-                description: options?.description,
-              });
-              return terminal.output;
-            }
-            if (terminal) {
-              throw new Error(terminal.error);
-            }
-
-            const suspension = {
-              kind: 'child_play',
-              boundaryId,
-              childRunId: childGovernance.currentRunId,
-              childPlayName: resolvedName,
-            } as const;
-            this.recordPendingChildPlayBoundary(suspension);
-            scheduledChildPlayCall?.release();
-            await this.waitForScheduledChildPlayQuiescence();
-            throw new PlayExecutionSuspendedError(
-              this.consumePendingChildPlaySuspension() ?? suspension,
-            );
-          }
-          // Inline child = pure function composition (ADR 0013). No durable
-          // child run: no playRuns doc, no start/settle round-trip, no
-          // OptimisticConcurrencyControlFailure fan-out. The child's tool
-          // receipts still land durably under the PARENT run (the inline
-          // execution scope keeps the parent's receipt.ownerRunId) scoped by the
-          // replay-stable composition namespace (which also enforces the
-          // per-row inline-invocation sanity cap at creation).
-          const compositionNamespace = childGovernance.currentRunId;
-          const childExecutionScope = deriveChildRunExecutionScope(
-            this.currentExecutionScope,
-            {
-              placement: 'inline',
-              runId: compositionNamespace,
-              playId: resolvedName,
-              receiptNamespace: compositionNamespace,
-            },
-          );
-          this.inlineChildAggregates.total += 1;
-          try {
-            // A scalar child is a normal function call on the parent's context.
-            // Async-local identity changes receipt and recursion scope without
-            // allocating another PlayContext, tool queue, drain loop, resource
-            // governor, or receipt client. Calls from every concurrent child
-            // therefore reach the same proven parent batching path.
-            const result = await inlineCompositionContext.run(
-              {
-                context: this,
-                executionScope: childExecutionScope,
-                governor: inlineChildGovernor!,
-                playName: resolvedName,
-                staticPipeline: resolvedPlay.staticPipeline ?? null,
-              },
-              () => this.executeResolvedPlay(resolvedPlay, this, input),
-            );
-            this.inlineChildAggregates.ok += 1;
-            if (rowStore) {
-              this.emitScopedFieldMetaUpdate({
-                rowId: rowStore.rowId,
-                key: rowStore.rowKey ?? null,
-                tableNamespace: rowStore.tableNamespace ?? null,
-                fieldName: rowStore.fieldName,
-                status: 'completed',
-                rowStatus: 'running',
-                stage: resolvedName,
-                provider: 'deepline_native',
-                error: null,
-                producer,
-                dataPatch: {},
-              });
-            }
-            this.recordPlayCallStep({
-              playId: resolvedName,
-              execution: options?.execution,
-              description: options?.description,
-            });
-            return result as TOutput;
-          } catch (childError) {
-            this.recordInlineChildFailure(resolvedName, childError);
-            throw childError;
-          }
-        } catch (error) {
-          if (isPlayExecutionSuspendedError(error)) {
-            throw error;
-          }
-          if (rowStore) {
-            this.emitScopedFieldMetaUpdate({
-              rowId: rowStore.rowId,
-              key: rowStore.rowKey ?? null,
-              tableNamespace: rowStore.tableNamespace ?? null,
-              fieldName: rowStore.fieldName,
-              status: 'failed',
-              rowStatus: 'running',
-              stage: resolvedName,
-              provider: 'deepline_native',
-              error: this.formatRuntimeError(error),
-              producer,
-              dataPatch: {},
-            });
-          }
-          throw error;
-        } finally {
-          childPlaySlot?.release();
+          receiptNamespace: compositionNamespace,
+        },
+      );
+      this.inlineChildAggregates.total += 1;
+      try {
+        // A scalar child is a normal function call on the parent's context.
+        // Async-local identity changes receipt and recursion scope without
+        // allocating another PlayContext, tool queue, drain loop, resource
+        // governor, or receipt client. Calls from every concurrent child
+        // therefore reach the same proven parent batching path.
+        const result = await inlineCompositionContext.run(
+          {
+            context: this,
+            executionScope: childExecutionScope,
+            governor: inlineChildGovernor,
+            playName: resolvedName,
+            staticPipeline: resolvedPlay.staticPipeline ?? null,
+          },
+          () => this.executeResolvedPlay(resolvedPlay, this, input),
+        );
+        this.inlineChildAggregates.ok += 1;
+        if (rowStore) {
+          this.emitScopedFieldMetaUpdate({
+            rowId: rowStore.rowId,
+            key: rowStore.rowKey ?? null,
+            tableNamespace: rowStore.tableNamespace ?? null,
+            fieldName: rowStore.fieldName,
+            status: 'completed',
+            rowStatus: 'running',
+            stage: resolvedName,
+            provider: 'deepline_native',
+            error: null,
+            producer,
+            dataPatch: {},
+          });
         }
-      };
-
-      return await executePlayCall();
-    } finally {
-      scheduledChildPlayCall?.release();
+        this.recordPlayCallStep({
+          playId: resolvedName,
+          execution: options?.execution === 'inline' ? 'inline' : undefined,
+          description: options?.description,
+        });
+        return result as TOutput;
+      } catch (childError) {
+        this.recordInlineChildFailure(resolvedName, childError);
+        throw childError;
+      }
+    } catch (error) {
+      if (isPlayExecutionSuspendedError(error)) {
+        throw error;
+      }
+      if (rowStore) {
+        this.emitScopedFieldMetaUpdate({
+          rowId: rowStore.rowId,
+          key: rowStore.rowKey ?? null,
+          tableNamespace: rowStore.tableNamespace ?? null,
+          fieldName: rowStore.fieldName,
+          status: 'failed',
+          rowStatus: 'running',
+          stage: resolvedName,
+          provider: 'deepline_native',
+          error: this.formatRuntimeError(error),
+          producer,
+          dataPatch: {},
+        });
+      }
+      throw error;
     }
   }
 
@@ -7196,25 +6671,17 @@ export class PlayContextImpl {
     const namespace = `child:${childPlayName}#${normalizedKey}${
       rowScopeKey ? `@${rowScopeKey}` : ''
     }`;
-    if (!this.inlineChildInvocationOrdinals.has(namespace)) {
-      // Per-row fan-width guard. `maxPlayCallDepth` (governor) bounds nesting;
-      // this bounds distinct inline invocations from ONE row scope so a
-      // resolver looping runPlay unbounded fails loudly on that row instead of
-      // leaking namespaces.
-      const rowInvocationCount =
-        (this.inlineChildInvocationsPerRow.get(rowScopeKey) ?? 0) + 1;
-      if (rowInvocationCount > MAX_INLINE_CHILD_INVOCATIONS_PER_ROW) {
+    if (rowScope) {
+      const namespaces =
+        rowScope.inlineChildInvocationNamespaces ??= new Set<string>();
+      namespaces.add(namespace);
+      if (namespaces.size > MAX_INLINE_CHILD_INVOCATIONS_PER_ROW) {
         throw new Error(
           `ctx.runPlay("${childPlayName}") exceeded the inline child invocation cap ` +
             `(${MAX_INLINE_CHILD_INVOCATIONS_PER_ROW} per row). A resolver is calling ` +
             'runPlay in an unbounded loop; give the batch ONE dataset child at play level instead.',
         );
       }
-      this.inlineChildInvocationsPerRow.set(rowScopeKey, rowInvocationCount);
-      this.inlineChildInvocationOrdinals.set(
-        namespace,
-        this.inlineChildInvocationOrdinals.size,
-      );
     }
     return namespace;
   }
@@ -7302,6 +6769,7 @@ export class PlayContextImpl {
   }
 
   async sleep(ms: number): Promise<void> {
+    this.assertInlineChildContract('suspending_child');
     if (this.#options.durableBoundaries) {
       const delayMs = Math.max(0, Math.round(ms));
       const boundaryId = this.durableBoundaryId(
@@ -8725,10 +8193,26 @@ export class PlayContextImpl {
           const retrySafeTransientHttp =
             retryPolicy?.retrySafeTransientHttp === true;
           let transportAttempt = 0;
-          const retryToolTransportFailure = async (
-            message: string,
-          ): Promise<void> => {
+          const retryToolTransportFailure = async (input: {
+            error: unknown;
+            elapsedMs: number;
+            requestId: string | null;
+            aborted: boolean;
+          }): Promise<void> => {
             transportAttempt += 1;
+            const diagnostic = describeTransportError(input.error);
+            this.log(
+              `[runtime.transport_failure] ${JSON.stringify({
+                tool_id: toolId,
+                gateway_origin: transportGatewayOriginForDiagnostic(url),
+                attempt: transportAttempt,
+                max_attempts: TOOL_EXECUTE_TRANSPORT_MAX_ATTEMPTS,
+                elapsed_ms: input.elapsedMs,
+                request_id: input.requestId,
+                aborted: input.aborted,
+                error: diagnostic,
+              })}`,
+            );
             if (transportAttempt < TOOL_EXECUTE_TRANSPORT_MAX_ATTEMPTS) {
               await this.governor.chargeBudget('retry');
               const retryAfterMs =
@@ -8738,14 +8222,14 @@ export class PlayContextImpl {
                 transportAttempt,
               );
               this.log(
-                `Tool ${toolId} transport failed calling ${url} on attempt ${transportAttempt}/${TOOL_EXECUTE_TRANSPORT_MAX_ATTEMPTS}; retrying after ${retryAfterMs}ms: ${message}`,
+                `Tool ${toolId} transport failed calling ${url} on attempt ${transportAttempt}/${TOOL_EXECUTE_TRANSPORT_MAX_ATTEMPTS}; retrying after ${retryAfterMs}ms: ${diagnostic.message ?? 'unknown transport error'}`,
               );
               await options?.parkProviderCall?.();
               await this.sleepWithCheckpointHeartbeat(retryAfterMs);
               return;
             }
             throw new ToolHttpError(
-              `Tool ${toolId} transport failed calling ${url} after ${transportAttempt}/${TOOL_EXECUTE_TRANSPORT_MAX_ATTEMPTS} attempts: ${message}`,
+              `Tool ${toolId} transport failed calling ${url} after ${transportAttempt}/${TOOL_EXECUTE_TRANSPORT_MAX_ATTEMPTS} attempts: ${diagnostic.message ?? 'unknown transport error'}`,
               null,
               0,
               'repairable',
@@ -8767,9 +8251,12 @@ export class PlayContextImpl {
                   : null;
             const providerIdempotencyKey =
               options?.providerIdempotencyKey?.trim() || durableCallReceiptKey;
+            // Every gateway request needs a correlation ID. When the call has
+            // an idempotency key, keep its stable ID across retries; otherwise
+            // give this individual attempt a fresh ID for gateway pairing.
             const deeplineRequestId = providerIdempotencyKey
               ? `ctx-tool-${stableDigest(providerIdempotencyKey).slice(0, 32)}`
-              : null;
+              : `ctx-tool-${crypto.randomUUID()}`;
             // Receipt ownership is a liveness contract, not a one-time check.
             // Keep it alive for the whole provider HTTP request. The cadence
             // comes from the store-issued expiry because a remote runner may
@@ -8837,10 +8324,10 @@ export class PlayContextImpl {
                       V2_EXECUTE_RESPONSE_CONTRACT,
                     [EXECUTE_RESPONSE_INTENT_HEADER]: 'dataset',
                     [EXECUTE_TOOL_METADATA_HEADER]: 'true',
-                    ...(deeplineRequestId
+                    'x-deepline-request-id': deeplineRequestId,
+                    ...(providerIdempotencyKey
                       ? {
-                          'x-deepline-request-id': deeplineRequestId,
-                          'x-deepline-idempotency-key': providerIdempotencyKey!,
+                          'x-deepline-idempotency-key': providerIdempotencyKey,
                         }
                       : {}),
                     ...(await this.vercelProtectionHeaders()),
@@ -8918,11 +8405,15 @@ export class PlayContextImpl {
                       `Tool ${toolId} runtime API call timed out after ${timeoutMs}ms.`,
                     )
                 : error;
-              const message =
-                transportError instanceof Error
-                  ? transportError.message
-                  : String(transportError);
-              await retryToolTransportFailure(message);
+              await retryToolTransportFailure({
+                error: transportError,
+                elapsedMs:
+                  providerCallStartedAt === null
+                    ? 0
+                    : Date.now() - providerCallStartedAt,
+                requestId: deeplineRequestId,
+                aborted: abortController?.signal.aborted === true,
+              });
               continue;
             } finally {
               if (timeoutHandle) {
@@ -8941,9 +8432,14 @@ export class PlayContextImpl {
                   bodyText: text,
                 })
               ) {
-                await retryToolTransportFailure(
-                  'the Deepline development tunnel returned a branded 502 before reaching the app origin',
-                );
+                await retryToolTransportFailure({
+                  error: new Error(
+                    'the Deepline development tunnel returned a branded 502 before reaching the app origin',
+                  ),
+                  elapsedMs: providerCallElapsedMs ?? 0,
+                  requestId: deeplineRequestId,
+                  aborted: false,
+                });
                 continue;
               }
               const authScopeChanged = parseToolExecuteAuthScopeChangedError({