deepline 0.1.11 → 0.1.19

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

@@ -17,10 +17,10 @@
  *     to load CJS at runtime). The play here is statically imported and
  *     bundled into the Worker script.
  *   - Workers don't have node:fs / source-map-support. Stack traces are raw.
- *   - Direct postgres (`pg` library) won't bundle for per-play Workers. This
- *     harness keeps the per-play bundle isolate-safe and sends heavy sheet IO
- *     to the long-lived harness Worker, which owns the Workers-compatible
- *     Postgres driver and chunked write path.
+ *   - Direct postgres (`pg` library) won't bundle for Workers. This harness
+ *     uses HTTP-only ctx — every ctx.csv / ctx.tool / row write goes through
+ *     the runtime API endpoint, not direct DB. That keeps the Worker bundle
+ *     compatible with the V8 isolate runtime.
  *
  * Status: experimental. First cut targets tool-basic (ctx.csv + ctx.map +
  * ctx.tool). Plays that depend on the full ctx surface (durable sleep,
@@ -33,13 +33,28 @@ import {
   type WorkflowEvent,
   type WorkflowStep,
 } from 'cloudflare:workers';
-import { type ExecutionPlan } from '../../../shared_libs/play-runtime/execution-plan';
+import {
+  chooseMapChunkSize,
+  deterministicMapChunkStepName,
+  type ExecutionPlan,
+} from '../../../shared_libs/play-runtime/execution-plan';
+import {
+  compileRequestsWithStrategy,
+  executeChunkedRequests,
+  type ChunkExecutionResult,
+} from '../../../shared_libs/play-runtime/batch-runtime';
+import { getDefaultPlayRuntimeBatchStrategy } from '../../../shared_libs/play-runtime/default-batch-strategies';
 import type { AnyBatchOperationStrategy } from '../../../shared_libs/play-runtime/batching-types';
 import {
-  runtimeBillingActions,
-  runtimeRunActions,
-  type RuntimeApiAction,
-} from '../../../shared_libs/play-runtime/runtime-actions';
+  createToolBatchExecutor,
+  type ToolBatchRequest,
+} from '../../../shared_libs/play-runtime/tool-batch-executor';
+import {
+  createToolExecuteResult,
+  isToolExecuteResult,
+  type ToolExecuteResult,
+  type ToolResultMetadataInput,
+} from '../../../shared_libs/play-runtime/tool-result';
 import type { PlayCallGovernanceSnapshot } from '../../../shared_libs/play-runtime/scheduler-backend';
 import type { PlayRuntimeManifestMap } from '../../../shared_libs/plays/compiler-manifest';
 import {
@@ -64,31 +79,15 @@ import {
 // re-bundle harness internals into per-play. Keep that in mind.
 import {
   harnessFetchStagedFile,
-  harnessPersistCompletedSheetRows,
-  harnessRuntimeApiCall,
   harnessStartSheetDataset,
   setHarnessBinding,
 } from '../../../sdk/src/plays/harness-stub';
 import {
-  chooseMapChunkSize,
-  deterministicMapChunkStepName,
-} from './runtime/execution-plan';
-import {
-  compileRequestsWithStrategy,
-  executeChunkedRequests,
-  getDefaultPlayRuntimeBatchStrategy,
-  type ChunkExecutionResult,
-} from './runtime/batching';
-import {
-  createToolBatchExecutor,
-  type ToolBatchRequest,
-} from './runtime/tool-batch';
-import {
-  createToolExecuteResult,
-  isToolExecuteResult,
-  type ToolExecuteResult,
-  type ToolResultMetadataInput,
-} from './runtime/tool-result';
+  applyCsvRenameProjection,
+  stripCsvProjectedFields,
+  cloneCsvAliasedRow,
+  type CsvRenameOptions,
+} from '../../../shared_libs/play-runtime/csv-rename';
 import { coordinatorRequestHeaders } from '../../../shared_libs/play-runtime/coordinator-headers';
 
 // The play's default export. The bundler injects this — see bundle-play-file.ts.
@@ -149,6 +148,19 @@ type WorkerEnv = {
   PLAY_ASSETS?: {
     readText(logicalPath: string): Promise<string>;
   };
+  /**
+   * In-process Fetcher constructed by the coordinator and handed to the
+   * per-graphHash play Worker. When present, runtime callbacks
+   * (`/api/v2/plays/internal/runtime`, `/api/v2/plays/internal/*`,
+   * `/api/v2/plays/runtime-tools/*`) skip the public callback URL and route
+   * directly through the coordinator's process to the configured app — saves
+   * the *.workers.dev → CF edge → cloudflared → localhost chain on every
+   * runtime callback. Absent on legacy coordinator deploys; the fetch
+   * helpers fall back to `globalThis.fetch(req.baseUrl + path)`.
+   */
+  RUNTIME_API?: {
+    fetch(input: Request): Promise<Response>;
+  };
   /**
    * Loopback RPC binding into the coordinator Worker. Used for CF-to-CF
    * child orchestration so nested plays do not bounce through a public
@@ -176,7 +188,7 @@ type WorkerEnv = {
     ): Promise<Record<string, unknown>>;
     recordPerfTrace(
       runId: string,
-      payload: DynamicWorkerPerfTracePayload,
+      payload: Record<string, unknown>,
     ): Promise<void>;
   };
   /**
@@ -192,8 +204,20 @@ type WorkerEnv = {
    * loud error. Loud failures > silent fallbacks.
    */
   HARNESS?: import('../../play-harness-worker/src/rpc-types').PlayHarnessRpc;
+  VERCEL_PROTECTION_BYPASS_TOKEN?: string;
 };
 
+let cachedRuntimeApiBinding: WorkerEnv['RUNTIME_API'] | null = null;
+let cachedRuntimeApiVercelBypassToken: string | null = null;
+function captureRuntimeApiBinding(env: WorkerEnv): void {
+  cachedRuntimeApiBinding = env.RUNTIME_API ?? null;
+  cachedRuntimeApiVercelBypassToken =
+    typeof env.VERCEL_PROTECTION_BYPASS_TOKEN === 'string' &&
+    env.VERCEL_PROTECTION_BYPASS_TOKEN.trim()
+      ? env.VERCEL_PROTECTION_BYPASS_TOKEN.trim()
+      : null;
+}
+
 let cachedCoordinatorBinding: WorkerEnv['COORDINATOR'] | null = null;
 function captureCoordinatorBinding(env: WorkerEnv): void {
   cachedCoordinatorBinding = env.COORDINATOR ?? null;
@@ -215,8 +239,10 @@ function captureHarnessBinding(env: WorkerEnv): void {
 
 /**
  * One-shot per-isolate harness wiring probe. Logs a single line that
- * reports broken wiring on this isolate's first run. Successful probes stay
- * silent so fresh-graph benchmark runs do not pay for diagnostic tail traffic.
+ * confirms whether `env.HARNESS` resolved to a live Worker on this
+ * isolate's first run. We use this as a low-noise diagnostic operators
+ * can grep for in any env — local dev, preview, prod — without having
+ * to plumb a separate health route or instrument SDK call sites.
  *
  * Behavior on fail:
  *   - Binding missing entirely → log clearly that HARNESS is unwired so
@@ -239,9 +265,8 @@ async function probeHarnessOnce(
   if (harnessProbeFiredForIsolate) return;
   harnessProbeFiredForIsolate = true;
   if (!env.HARNESS) {
-    void runPrefix;
-    console.warn(
-      `[harness-probe] env.HARNESS unwired — coordinator did not pass the binding. ` +
+    console.log(
+      `${runPrefix} [harness-probe] env.HARNESS unwired — coordinator did not pass the binding. ` +
         `Per-play SDK call sites that reach into the harness will throw clearly. ` +
         `See apps/play-harness-worker/README.md.`,
     );
@@ -251,104 +276,33 @@ async function probeHarnessOnce(
     typeof (env.HARNESS as { ping?: () => Promise<{ ok: true; ts: number }> })
       .ping !== 'function'
   ) {
-    void runPrefix;
-    console.warn(
-      `[harness-probe] env.HARNESS is present but does not expose ping(); ` +
+    console.log(
+      `${runPrefix} [harness-probe] env.HARNESS is present but does not expose ping(); ` +
         `continuing and relying on the first real call to fail if the contract changed.`,
     );
     return;
   }
   try {
-    await env.HARNESS.ping();
+    const result = await env.HARNESS.ping();
+    console.log(
+      `${runPrefix} [harness-probe] env.HARNESS connected ts=${result.ts}`,
+    );
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    void runPrefix;
-    console.warn(
-      `[harness-probe] env.HARNESS resolved but ping failed: ${message}`,
+    console.log(
+      `${runPrefix} [harness-probe] env.HARNESS resolved but ping failed: ${message}`,
     );
   }
 }
 /**
- * Routes Deepline API requests through the long-lived harness Worker. Passing
- * explicit JSON over typed RPC avoids Request/Authorization header cloning
- * quirks across WorkerEntrypoint boundaries.
+ * Routes runtime API requests through the in-process RUNTIME_API binding when
+ * Cloudflare exposes the coordinator WorkerEntrypoint export. Some workflow
+ * execution paths do not expose those exports; there we keep the older public
+ * fetch transport so the play still reaches the same authenticated handler.
  */
 const RUNTIME_API_TIMEOUT_MS = 30_000;
 const RUNTIME_API_PLAY_RUN_TIMEOUT_MS = 75_000;
-const HARNESS_RUNTIME_FORWARD_HEADERS = [
-  'x-deepline-request-id',
-  EXECUTE_TOOL_METADATA_HEADER,
-] as const;
-const TOOL_HTTP_MAX_ATTEMPTS = 3;
-const TOOL_RETRY_AFTER_DEFAULT_MS = 1_000;
-const TOOL_RETRY_AFTER_MAX_MS = 30 * 60 * 1_000;
-const TOOL_IN_MEMORY_RETRY_SLEEP_MAX_MS = 30_000;
-const TRANSIENT_HTTP_RETRY_SAFE_TOOL_IDS = new Set(['test_transient_500']);
-
-function parseRetryAfterMs(header: string | null): number {
-  if (!header) return TOOL_RETRY_AFTER_DEFAULT_MS;
-  const numeric = Number(header);
-  if (Number.isFinite(numeric) && numeric >= 0) {
-    return Math.max(1, Math.ceil(numeric * 1_000));
-  }
-  const retryAt = Date.parse(header);
-  if (Number.isFinite(retryAt)) {
-    return Math.max(1, retryAt - Date.now());
-  }
-  return TOOL_RETRY_AFTER_DEFAULT_MS;
-}
-
-function isRetryableToolHttpStatus(toolId: string, status: number): boolean {
-  if (status === 429) return true;
-  return (
-    status >= 500 &&
-    status < 600 &&
-    TRANSIENT_HTTP_RETRY_SAFE_TOOL_IDS.has(toolId)
-  );
-}
-
-async function sleepForToolRetry(input: {
-  workflowStep?: WorkflowStep;
-  toolId: string;
-  status: number;
-  attempt: number;
-  retryAfterMs: number;
-  retryKey?: string | null;
-  toolInput: Record<string, unknown>;
-}): Promise<void> {
-  const retryAfterMs = Math.max(1, Math.ceil(input.retryAfterMs));
-  if (retryAfterMs > TOOL_RETRY_AFTER_MAX_MS) {
-    throw new Error(
-      `tool ${input.toolId} returned ${input.status} with retry-after ${retryAfterMs}ms, above max supported retry wait ${TOOL_RETRY_AFTER_MAX_MS}ms.`,
-    );
-  }
-
-  if (input.workflowStep) {
-    const inputHash = (
-      await hashJson({
-        key: input.retryKey ?? '',
-        input: input.toolInput,
-      })
-    ).slice(0, 16);
-    await (
-      input.workflowStep.sleep as unknown as (
-        name: string,
-        duration: number,
-      ) => Promise<void>
-    )(
-      `tool-retry:${input.toolId}:${input.status}:attempt-${input.attempt}:${inputHash}`,
-      retryAfterMs,
-    );
-    return;
-  }
-
-  if (retryAfterMs > TOOL_IN_MEMORY_RETRY_SLEEP_MAX_MS) {
-    throw new Error(
-      `tool ${input.toolId} returned ${input.status} with retry-after ${retryAfterMs}ms, but no durable workflow step was available.`,
-    );
-  }
-  await new Promise((resolve) => setTimeout(resolve, retryAfterMs));
-}
+let loggedMissingRuntimeApiBinding = false;
 
 async function fetchRuntimeApi(
   baseUrl: string,
@@ -359,50 +313,54 @@ async function fetchRuntimeApi(
     path === '/api/v2/plays/run'
       ? RUNTIME_API_PLAY_RUN_TIMEOUT_MS
       : RUNTIME_API_TIMEOUT_MS;
-  const headers = new Headers(init.headers);
-  const authorization = headers.get('authorization') ?? '';
-  const bearerPrefix = 'Bearer ';
-  if (!authorization.startsWith(bearerPrefix)) {
-    throw new Error(
-      `[play-harness] Deepline API call requires a Bearer executor token. path=${path}`,
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const mergedInit: RequestInit = {
+      ...init,
+      headers: runtimeApiHeaders(init.headers, cachedRuntimeApiBinding == null),
+      signal: controller.signal,
+    };
+    if (!cachedRuntimeApiBinding) {
+      if (!loggedMissingRuntimeApiBinding) {
+        loggedMissingRuntimeApiBinding = true;
+        console.warn(
+          `[play-harness] RUNTIME_API binding missing; using public runtime API transport. path=${path}`,
+        );
+      }
+      return await fetch(`${baseUrl.replace(/\/$/, '')}${path}`, mergedInit);
+    }
+    return await cachedRuntimeApiBinding.fetch(
+      new Request(`${baseUrl.replace(/\/$/, '')}${path}`, mergedInit),
     );
-  }
-
-  const forwardedHeaders: Record<string, string> = {};
-  for (const name of HARNESS_RUNTIME_FORWARD_HEADERS) {
-    const value = headers.get(name);
-    if (value) forwardedHeaders[name] = value;
-  }
-
-  let body: unknown = {};
-  if (typeof init.body === 'string' && init.body.trim()) {
-    try {
-      body = JSON.parse(init.body) as unknown;
-    } catch (error) {
+  } catch (err) {
+    if (err instanceof Error && err.name === 'AbortError') {
       throw new Error(
-        `[play-harness] Deepline API call requires a JSON string body. path=${path} error=${
-          error instanceof Error ? error.message : String(error)
-        }`,
+        `[play-harness] runtime API call timed out after ${timeoutMs}ms. path=${path} baseUrl=${baseUrl}`,
       );
     }
-  } else if (init.body != null) {
-    throw new Error(
-      `[play-harness] Deepline API call requires a JSON string body. path=${path}`,
-    );
+    throw err;
+  } finally {
+    clearTimeout(timer);
   }
+}
 
-  void baseUrl;
-  const result = await harnessRuntimeApiCall({
-    executorToken: authorization.slice(bearerPrefix.length).trim(),
-    path,
-    body,
-    headers: Object.keys(forwardedHeaders).length ? forwardedHeaders : undefined,
-    timeoutMs,
-  });
-  return new Response(result.body, {
-    status: result.status,
-    headers: result.headers,
-  });
+function runtimeApiHeaders(
+  headers: HeadersInit | undefined,
+  includeVercelBypass: boolean,
+): Headers {
+  const next = new Headers(headers);
+  if (includeVercelBypass) {
+    const bypassToken = cachedVercelProtectionBypassToken();
+    if (bypassToken) {
+      next.set('x-vercel-protection-bypass', bypassToken);
+    }
+  }
+  return next;
+}
+
+function cachedVercelProtectionBypassToken(): string | null {
+  return cachedRuntimeApiVercelBypassToken;
 }
 
 const WORKER_PLAY_CALL_LIMITS = {
@@ -424,6 +382,20 @@ function makeWorkerDataset<T extends Record<string, unknown>>(
     count?: number;
     datasetKind?: 'csv' | 'map';
     cacheSummary?: string | null;
+    workProgress?: {
+      total: number;
+      executed: number;
+      reused: number;
+      skipped: number;
+      pending: number;
+      failed: number;
+      degraded?: boolean;
+      duplicates?: {
+        exact?: number;
+        semantic?: number;
+        rejected?: number;
+      };
+    };
   },
 ): T[] & {
   count(): Promise<number>;
@@ -437,6 +409,7 @@ function makeWorkerDataset<T extends Record<string, unknown>>(
   const count = Math.max(0, Math.floor(options?.count ?? rows.length));
   const datasetKind = options?.datasetKind ?? 'map';
   const cacheSummary = options?.cacheSummary ?? null;
+  const workProgress = options?.workProgress;
   // Build the array result. JSON.stringify on arrays calls toJSON only if
   // present on the array itself — we attach below. The dataset metadata is
   // also exposed via own properties so plays can `enriched.count()` etc.
@@ -448,7 +421,7 @@ function makeWorkerDataset<T extends Record<string, unknown>>(
     datasetId: string;
     tableNamespace: string;
   };
-  const previewLimit = 10;
+  const previewLimit = 5;
   const inferredColumns = (() => {
     const cols = new Set<string>();
     for (const r of rows) {
@@ -489,6 +462,10 @@ function makeWorkerDataset<T extends Record<string, unknown>>(
     value: cacheSummary,
     enumerable: false,
   });
+  Object.defineProperty(arr, '__deeplineWorkProgress', {
+    value: workProgress,
+    enumerable: false,
+  });
   // Plays often `return { rows: dataset, count: N }`. JSON.stringify on the
   // array would normally produce `[row, row, ...]` — we want the dataset
   // envelope shape instead so assertions seeing `result.rows.columns` pass.
@@ -509,6 +486,9 @@ function makeWorkerDataset<T extends Record<string, unknown>>(
         preview: plainRows,
         tableNamespace: name,
         ...(cacheSummary ? { cacheSummary } : {}),
+        ...(workProgress
+          ? { _metadata: { workProgress } }
+          : {}),
       };
     },
     enumerable: false,
@@ -528,65 +508,30 @@ type RunnerEvent =
   | { type: 'error'; message: string; stack?: string; ts: number };
 
 type WorkflowRunOutput = {
+  playName: string;
   result: unknown;
   outputRows: number;
   durationMs: number;
 };
 
-type DynamicWorkerPerfTracePayload = {
-  ts: number;
-  source: 'dynamic_worker';
-  runId: string;
-  phase: string;
-  ms: number;
-  graphHash?: string | null;
-  [key: string]: unknown;
-};
-
 function nowMs(): number {
   return Date.now();
 }
 
-function recordDynamicWorkerPerfTrace(input: {
-  env: WorkerEnv;
-  runId: string;
-  phase: string;
-  ms: number;
-  graphHash?: string | null;
-  extra?: Record<string, unknown>;
-  waitUntil?: (promise: Promise<unknown>) => void;
-}): void {
-  if (!input.runId || !input.phase) return;
-  const payload: DynamicWorkerPerfTracePayload = {
-    ts: Date.now(),
-    source: 'dynamic_worker',
-    runId: input.runId,
-    phase: input.phase,
-    ms: input.ms,
-    ...(input.graphHash ? { graphHash: input.graphHash } : {}),
-    ...(input.extra ?? {}),
-  };
-  console.log(`[perf-trace] ${JSON.stringify(payload)}`);
-  const send = input.env.COORDINATOR?.recordPerfTrace(
-    input.runId,
-    payload,
-  ).catch((error) => {
-    console.error(
-      `[play-harness] non-fatal dynamic trace append failed runId=${input.runId}: ${
-        error instanceof Error ? error.message : String(error)
-      }`,
-    );
-  });
-  if (send && input.waitUntil) {
-    input.waitUntil(send);
-  }
-}
-
 function makeRequestId(): string {
   // Workers crypto.randomUUID is available without nodejs_compat.
   return crypto.randomUUID();
 }
 
+function publicCsvInputRow<T extends Record<string, unknown>>(row: T): T {
+  const stripped = stripCsvProjectedFields(row) as Record<string, unknown>;
+  return Object.fromEntries(
+    Object.entries(stripped).filter(
+      ([fieldName]) => !fieldName.startsWith('__deepline'),
+    ),
+  ) as T;
+}
+
 /**
  * Strip credentials and JWT-shaped tokens from any string before it lands in
  * a log buffer or upstream error message. The harness routinely echoes
@@ -609,11 +554,11 @@ function redactSecretsFromLogString(value: string): string {
 async function postRuntimeApi<T>(
   baseUrl: string,
   executorToken: string,
-  body: RuntimeApiAction,
+  body: unknown,
 ): Promise<T> {
-  // Routes through the long-lived harness Worker so the real HTTPS request is
-  // assembled after the RPC boundary, preserving the executor Authorization
-  // header while keeping HTTP client code out of per-play bundles.
+  // Routes through the in-process RUNTIME_API binding when present; otherwise
+  // falls back to a public fetch against `${baseUrl}${path}`. Either path
+  // hits the same handler with the same auth — only the transport changes.
   const res = await fetchRuntimeApi(baseUrl, '/api/v2/plays/internal/runtime', {
     method: 'POST',
     headers: {
@@ -674,7 +619,7 @@ function describeRuntimeApiBody(body: unknown): string {
 async function postRuntimeApiBestEffort(
   baseUrl: string,
   executorToken: string,
-  body: RuntimeApiAction,
+  body: unknown,
 ): Promise<boolean> {
   try {
     await postRuntimeApi(baseUrl, executorToken, body);
@@ -689,67 +634,6 @@ async function postRuntimeApiBestEffort(
   }
 }
 
-type WorkerRuntimeTransport = {
-  postRuntimeApi<T>(body: RuntimeApiAction): Promise<T>;
-  postRuntimeApiBestEffort(body: RuntimeApiAction): Promise<boolean>;
-  submitChild(body: Record<string, unknown>): Promise<{
-    workflowId?: string;
-    runId?: string;
-    status?: string;
-    mode?: string;
-    output?: unknown;
-    result?: unknown;
-    error?: unknown;
-    logs?: string[];
-    timings?: Array<{ phase: string; ms: number }>;
-  }>;
-  signalParentTerminal(input: {
-    status: 'completed' | 'failed' | 'cancelled';
-    result?: Record<string, unknown> | null;
-    error?: string | null;
-  }): Promise<void>;
-};
-
-function createWorkerRuntimeTransport(req: RunRequest): WorkerRuntimeTransport {
-  return {
-    postRuntimeApi: <T>(body: RuntimeApiAction) =>
-      postRuntimeApi<T>(req.baseUrl, req.executorToken, body),
-    postRuntimeApiBestEffort: (body: RuntimeApiAction) =>
-      postRuntimeApiBestEffort(req.baseUrl, req.executorToken, body),
-    submitChild: (body: Record<string, unknown>) =>
-      submitChildPlayThroughCoordinator({ req, body }),
-    signalParentTerminal: (input) =>
-      signalParentPlayTerminal({ req, ...input }),
-  };
-}
-
-type WorkerChildPlayExecutor = {
-  submit(
-    body: Record<string, unknown>,
-  ): ReturnType<WorkerRuntimeTransport['submitChild']>;
-  waitTerminal(input: {
-    workflowStep?: WorkflowStep;
-    workflowId: string;
-    playName: string;
-    key: string;
-    timeoutMs: number;
-  }): Promise<unknown>;
-};
-
-function createWorkerChildPlayExecutor(input: {
-  req: RunRequest;
-  transport: WorkerRuntimeTransport;
-}): WorkerChildPlayExecutor {
-  return {
-    submit: (body) => input.transport.submitChild(body),
-    waitTerminal: (waitInput) =>
-      waitForChildPlayTerminalEvent({
-        req: input.req,
-        ...waitInput,
-      }),
-  };
-}
-
 async function submitChildPlayThroughCoordinator(input: {
   req: RunRequest;
   body: unknown;
@@ -792,7 +676,17 @@ async function submitChildPlayThroughCoordinator(input: {
       },
     );
     const text = await res.text().catch(() => '');
-    let parsed: { workflowId?: string; runId?: string; error?: unknown } = {};
+    let parsed: {
+      workflowId?: string;
+      runId?: string;
+      status?: string;
+      mode?: string;
+      output?: unknown;
+      result?: unknown;
+      error?: unknown;
+      logs?: string[];
+      timings?: Array<{ phase: string; ms: number }>;
+    } = {};
     try {
       parsed = text ? JSON.parse(text) : {};
     } catch {
@@ -880,6 +774,11 @@ function childPlayEventKey(input: { key: string; workflowId: string }): string {
   return `child_play_${hashChildPlayEventKey(`${input.key}:${input.workflowId}`)}_${readableKey}`;
 }
 
+function workflowTimeoutFromMs(timeoutMs: number): string {
+  const seconds = Math.max(1, Math.ceil(timeoutMs / 1000));
+  return `${seconds} second${seconds === 1 ? '' : 's'}`;
+}
+
 async function waitForChildPlayTerminalEvent(input: {
   req: RunRequest;
   workflowStep?: WorkflowStep;
@@ -900,11 +799,11 @@ async function waitForChildPlayTerminalEvent(input: {
   const event = (await (
     input.workflowStep.waitForEvent as unknown as (
       name: string,
-      options: { type: string; timeout: number },
+      options: { type: string; timeout: string },
     ) => Promise<{ payload: unknown }>
   )(`child_play_terminal:${eventKey}`, {
     type: integrationEventType(eventKey),
-    timeout: input.timeoutMs,
+    timeout: workflowTimeoutFromMs(input.timeoutMs),
   })) as { payload: unknown };
   const rawPayload = isRecord(event.payload) ? event.payload : {};
   const payload = isRecord(rawPayload.data) ? rawPayload.data : rawPayload;
@@ -998,11 +897,7 @@ async function signalParentPlayTerminal(input: {
 
 async function executeTool(
   req: RunRequest,
-  args: {
-    toolId: string;
-    input: Record<string, unknown>;
-    retryKey?: string | null;
-  },
+  args: { id: string; toolId: string; input: Record<string, unknown> },
   workflowStep?: WorkflowStep,
 ): Promise<ToolExecuteResult> {
   if (args.toolId === 'test_wait_for_event' && workflowStep) {
@@ -1018,76 +913,52 @@ async function executeTool(
   // service bindings, NOT through HTTP from this worker. Removing the
   // dispatcher-side coordinatorUrl plumbing intentionally turns the old
   // HTTP-based dedup helpers into dead code.
-  return callToolDirect(
-    req,
-    args.toolId,
-    args.input,
-    workflowStep,
-    args.retryKey,
-  );
+  return callToolDirect(req, args);
 }
 
-function integrationEventType(eventKey: string): string {
-  return workflowEventType(`integration_event_${eventKey}`);
+function isToolExecuteRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
 
-const activeSyntheticIntegrationWaitsByRun = new Map<
-  string,
-  Map<string, number>
->();
-
-function updateActiveSyntheticIntegrationWait(input: {
-  runId: string;
-  eventKey: string;
-  timeoutMs: number;
-  waiting: boolean;
-}): { eventKey: string; waitUntil: number } | null {
-  const waits =
-    activeSyntheticIntegrationWaitsByRun.get(input.runId) ??
-    new Map<string, number>();
-  if (input.waiting) {
-    waits.set(input.eventKey, Date.now() + input.timeoutMs);
-  } else {
-    waits.delete(input.eventKey);
+function normalizeToolExecuteArgs(
+  requestOrKey: unknown,
+  toolId?: unknown,
+  input?: unknown,
+): { id: string; toolId: string; input: Record<string, unknown> } {
+  if (isToolExecuteRecord(requestOrKey)) {
+    const id = requestOrKey.id;
+    const tool = requestOrKey.tool;
+    const requestInput = requestOrKey.input;
+    if (
+      typeof id !== 'string' ||
+      !id.trim() ||
+      typeof tool !== 'string' ||
+      !tool ||
+      !isToolExecuteRecord(requestInput)
+    ) {
+      throw new Error(
+        'ctx.tools.execute({ id, tool, input }) requires a non-empty id, tool string, and input object.',
+      );
+    }
+    return { id: id.trim(), toolId: tool, input: requestInput };
   }
-  if (waits.size === 0) {
-    activeSyntheticIntegrationWaitsByRun.delete(input.runId);
-    return null;
+
+  if (
+    typeof requestOrKey !== 'string' ||
+    !requestOrKey.trim() ||
+    typeof toolId !== 'string' ||
+    !toolId ||
+    !isToolExecuteRecord(input)
+  ) {
+    throw new Error(
+      'ctx.tools.execute(key, toolId, input) requires a tool ID and input object.',
+    );
   }
-  activeSyntheticIntegrationWaitsByRun.set(input.runId, waits);
-  const firstEntry = waits.entries().next().value;
-  if (!firstEntry) return null;
-  const [eventKey, waitUntil] = firstEntry;
-  return { eventKey, waitUntil };
+  return { id: requestOrKey.trim(), toolId, input };
 }
 
-async function updateSyntheticIntegrationWaitStatus(input: {
-  req: RunRequest;
-  eventKey: string;
-  timeoutMs: number;
-  waiting: boolean;
-}): Promise<void> {
-  const activeWait = updateActiveSyntheticIntegrationWait({
-    runId: input.req.runId,
-    eventKey: input.eventKey,
-    timeoutMs: input.timeoutMs,
-    waiting: input.waiting,
-  });
-  await postRuntimeApiBestEffort(
-    input.req.baseUrl,
-    input.req.executorToken,
-    runtimeRunActions.updateStatus({
-      playId: input.req.runId,
-      status: 'running',
-      runtimeBackend: 'cf_workflows_dynamic_worker',
-      waitKind: activeWait ? 'integration_event_batch' : null,
-      waitUntil: activeWait?.waitUntil ?? null,
-      activeBoundaryId: activeWait
-        ? `integration_event:${activeWait.eventKey}`
-        : null,
-      lastCheckpointAt: Date.now(),
-    }),
-  );
+function integrationEventType(eventKey: string): string {
+  return workflowEventType(`integration_event_${eventKey}`);
 }
 
 async function waitForSyntheticIntegrationEvent(
@@ -1103,23 +974,26 @@ async function waitForSyntheticIntegrationEvent(
     typeof input.timeout_ms === 'number' && Number.isFinite(input.timeout_ms)
       ? Math.max(1, Math.round(input.timeout_ms))
       : 30_000;
+  await postRuntimeApiBestEffort(req.baseUrl, req.executorToken, {
+    action: 'update_run_status',
+    playId: req.runId,
+    status: 'running',
+    runtimeBackend: 'cf_workflows_dynamic_worker',
+    waitKind: 'integration_event_batch',
+    waitUntil: nowMs() + timeoutMs,
+    activeBoundaryId: `integration_event:${eventKey}`,
+    lastCheckpointAt: nowMs(),
+  });
   try {
-    const eventPromise = (
+    const event = (await (
       workflowStep.waitForEvent as unknown as (
         name: string,
-        options: { type: string; timeout: number },
+        options: { type: string; timeout: string },
       ) => Promise<{ payload: unknown }>
     )(`integration_event:${eventKey}`, {
       type: integrationEventType(eventKey),
-      timeout: timeoutMs,
-    });
-    await updateSyntheticIntegrationWaitStatus({
-      req,
-      eventKey,
-      timeoutMs,
-      waiting: true,
-    });
-    const event = (await eventPromise) as { payload: unknown };
+      timeout: workflowTimeoutFromMs(timeoutMs),
+    })) as { payload: unknown };
     const payload =
       event.payload &&
       typeof event.payload === 'object' &&
@@ -1152,23 +1026,14 @@ async function waitForSyntheticIntegrationEvent(
       resumed: false,
       timed_out: true,
     };
-  } finally {
-    await updateSyntheticIntegrationWaitStatus({
-      req,
-      eventKey,
-      timeoutMs,
-      waiting: false,
-    });
   }
 }
 
 async function callToolDirect(
   req: RunRequest,
-  toolId: string,
-  input: Record<string, unknown>,
-  workflowStep?: WorkflowStep,
-  retryKey?: string | null,
+  args: { id: string; toolId: string; input: Record<string, unknown> },
 ): Promise<ToolExecuteResult> {
+  const { id, toolId, input } = args;
   if (toolId === 'test_rate_limit') {
     return wrapWorkerToolResult(
       toolId,
@@ -1184,60 +1049,56 @@ async function callToolDirect(
     );
   }
   const path = `/api/v2/integrations/${encodeURIComponent(toolId)}/execute`;
-  let res!: Response;
-  for (let attempt = 1; ; attempt += 1) {
-    res = await fetchRuntimeApi(req.baseUrl, path, {
+  const maxAttempts = 3;
+  let lastError: Error | null = null;
+
+  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+    const res = await fetchRuntimeApi(req.baseUrl, path, {
       method: 'POST',
       headers: {
         'content-type': 'application/json',
         authorization: `Bearer ${req.executorToken}`,
-        'x-deepline-request-id': makeRequestId(),
+        'x-deepline-request-id': `${req.runId}:${toolId}:${id}:attempt:${attempt}`,
         [EXECUTE_TOOL_METADATA_HEADER]: 'true',
       },
       body: JSON.stringify({ payload: input }),
     });
-    const retryable = isRetryableToolHttpStatus(toolId, res.status);
-    if (!retryable || attempt >= TOOL_HTTP_MAX_ATTEMPTS) {
-      break;
+    if (res.ok) {
+      const body = (await res.json()) as Record<string, unknown>;
+      const result = (body.result ?? body) as unknown;
+      const status =
+        typeof body.status === 'string'
+          ? body.status
+          : result == null
+            ? 'no_result'
+            : 'completed';
+      return wrapWorkerToolResult(
+        toolId,
+        result,
+        parseExecuteToolMetadata(toolId, body),
+        status,
+      );
     }
-    const retryAfterMs = parseRetryAfterMs(res.headers.get('retry-after'));
-    console.log(
-      `[play-harness] tool ${toolId} returned ${res.status}; retrying after ${retryAfterMs}ms attempt=${attempt}/${TOOL_HTTP_MAX_ATTEMPTS}`,
-    );
-    await res.body?.cancel().catch(() => undefined);
-    await sleepForToolRetry({
-      workflowStep,
-      toolId,
-      status: res.status,
-      attempt,
-      retryAfterMs,
-      retryKey,
-      toolInput: input,
-    });
-  }
-  if (!res.ok) {
+
     const text = await res.text().catch(() => '');
-    throw new Error(`tool ${toolId} ${res.status}: ${text.slice(0, 500)}`);
+    lastError = new Error(
+      `tool ${toolId} ${res.status} attempt ${attempt}/${maxAttempts}: ${text.slice(0, 500)}`,
+    );
+    const retryable =
+      res.status === 429 ||
+      (res.status >= 500 && WORKER_RETRY_SAFE_5XX_TOOLS.has(toolId));
+    if (!retryable || attempt >= maxAttempts) {
+      throw lastError;
+    }
+    const retryAfterSeconds = Number(res.headers.get('retry-after'));
+    const delayMs =
+      Number.isFinite(retryAfterSeconds) && retryAfterSeconds > 0
+        ? Math.min(5_000, Math.ceil(retryAfterSeconds * 1000))
+        : 1_000;
+    await new Promise((resolve) => setTimeout(resolve, delayMs));
   }
-  // Match shared_libs/play-runtime/context.ts:callToolAPI:
-  //   data = body
-  //   normalized = normalizePlayToolResult(data.result ?? data)
-  // where normalizePlayToolResult recursively unwraps `{data: X}` → `X`.
-  const body = (await res.json()) as Record<string, unknown>;
-  const picked = (body.result ?? body) as unknown;
-  const result = normalizePlayToolResult(picked);
-  const status =
-    typeof body.status === 'string'
-      ? body.status
-      : result == null
-        ? 'no_result'
-        : 'completed';
-  return wrapWorkerToolResult(
-    toolId,
-    result,
-    parseExecuteToolMetadata(toolId, body),
-    status,
-  );
+
+  throw lastError ?? new Error(`tool ${toolId} failed before execution.`);
 }
 
 function parseExecuteToolMetadata(
@@ -1482,22 +1343,23 @@ type WorkerInlineWaterfallSpec = {
           input: Record<string, unknown>,
           ctx: {
             tools: {
-              execute(request: WorkerToolExecutionRequest): Promise<unknown>;
+              execute(
+                key: string,
+                toolId: string,
+                input: Record<string, unknown>,
+              ): Promise<unknown>;
             };
-            tool(request: WorkerToolExecutionRequest): Promise<unknown>;
+            tool(
+              key: string,
+              toolId: string,
+              input: Record<string, unknown>,
+            ): Promise<unknown>;
           },
         ) => unknown | Promise<unknown>;
       }
   >;
 };
 
-type WorkerToolExecutionRequest = {
-  id: string;
-  tool: string;
-  input: Record<string, unknown>;
-  description?: string;
-};
-
 type WorkerWaterfallOptions = {
   providers?: string[];
   min_results?: number;
@@ -1524,8 +1386,8 @@ type WorkerStepResolution = {
 };
 
 type WorkerToolBatchRequest = {
+  id: string;
   toolId: string;
-  retryKey?: string | null;
   input: Record<string, unknown>;
   workflowStep?: WorkflowStep;
   resolve: (value: unknown) => void;
@@ -1533,6 +1395,7 @@ type WorkerToolBatchRequest = {
 };
 
 const WORKER_TOOL_BATCH_GRACE_MS = 15;
+const WORKER_RETRY_SAFE_5XX_TOOLS = new Set(['test_transient_500']);
 
 function stepProgramColumnName(parentField: string, stepId: string): string {
   return sqlSafePlayColumnName(`${parentField}.${stepId}`);
@@ -1545,20 +1408,13 @@ class WorkerToolBatchScheduler {
   constructor(private readonly req: RunRequest) {}
 
   execute(
-    retryKey: string | null,
+    id: string,
     toolId: string,
     input: Record<string, unknown>,
     workflowStep?: WorkflowStep,
   ): Promise<unknown> {
     return new Promise((resolve, reject) => {
-      this.queue.push({
-        toolId,
-        retryKey,
-        input,
-        workflowStep,
-        resolve,
-        reject,
-      });
+      this.queue.push({ id, toolId, input, workflowStep, resolve, reject });
       this.scheduleDrain();
     });
   }
@@ -1612,7 +1468,7 @@ class WorkerToolBatchScheduler {
             request.resolve(
               await executeTool(
                 this.req,
-                { toolId, input: request.input, retryKey: request.retryKey },
+                { id: request.id, toolId, input: request.input },
                 request.workflowStep,
               ),
             );
@@ -1662,17 +1518,11 @@ async function executeBatchedWorkerToolGroup(input: {
     requests: compiledBatches,
     batchSize: Math.max(1, Math.min(4, compiledBatches.length || 1)),
     execute: async (batch) =>
-      await executeTool(
-        input.req,
-        {
-          toolId: batch.batchOperation,
-          input: batch.batchPayload,
-          retryKey: batch.memberRequests
-            .map((request) => request.retryKey ?? '')
-            .join('|'),
-        },
-        batch.memberRequests[0]?.workflowStep,
-      ),
+      await executeTool(input.req, {
+        id: `batch:${batch.memberRequests.map((request) => request.id).join('|')}`,
+        toolId: batch.batchOperation,
+        input: batch.batchPayload,
+      }),
     onChunkComplete: async (
       chunkResults: Array<
         ChunkExecutionResult<(typeof compiledBatches)[number], unknown>
@@ -1680,7 +1530,9 @@ async function executeBatchedWorkerToolGroup(input: {
     ) => {
       for (const entry of chunkResults) {
         const batchResult = isToolExecuteResult(entry.result)
-          ? entry.result.result
+          ? isRecordLike(entry.result.result)
+            ? entry.result.result.data
+            : undefined
           : entry.result;
         const splitResults =
           batchResult != null
@@ -1741,6 +1593,7 @@ type WorkerMapChunkSummary<T extends Record<string, unknown>> = {
   rowsWritten: number;
   rowsExecuted: number;
   rowsCached: number;
+  rowsDuplicateReused: number;
   rowsInserted: number;
   rowsSkipped: number;
   outputDatasetId: string;
@@ -1785,7 +1638,6 @@ type WorkerStepProgram = {
 type WorkerMapOptions = {
   description?: string;
   concurrency?: number;
-  staleAfterSeconds?: number;
   key?:
     | string
     | readonly string[]
@@ -1795,46 +1647,6 @@ type WorkerMapOptions = {
       ) => string | number | readonly unknown[]);
 };
 
-function workerMapRowIdentity(
-  row: Record<string, unknown>,
-  tableNamespace: string,
-  opts: WorkerMapOptions | undefined,
-  index = 0,
-): string {
-  const key = opts?.key;
-  if (!key) return derivePlayRowIdentity(row, tableNamespace);
-	  const raw =
-	    typeof key === 'function'
-	      ? key(row, index)
-	      : typeof key === 'string'
-	        ? row[key]
-	        : key.map((fieldName) => row[fieldName]);
-  const normalized = normalizeWorkerExplicitMapKey(raw);
-  if (!normalized) {
-    throw new Error(
-      `ctx.map("${tableNamespace}") key produced an empty value for row ${index}. ` +
-        'Use non-empty stable input columns or return a non-empty string, number, or tuple.',
-    );
-  }
-  return derivePlayRowIdentityFromKey(normalized, tableNamespace);
-}
-
-function normalizeWorkerExplicitMapKey(value: unknown): string {
-  if (Array.isArray(value)) {
-    const parts = value.map((entry) =>
-      normalizeWorkerExplicitMapKeyPart(entry),
-    );
-    return parts.every(Boolean) ? JSON.stringify(parts) : '';
-  }
-  return normalizeWorkerExplicitMapKeyPart(value);
-}
-
-function normalizeWorkerExplicitMapKeyPart(value: unknown): string {
-  if (typeof value === 'number')
-    return Number.isFinite(value) ? String(value) : '';
-  return String(value ?? '').trim();
-}
-
 function isWorkerStepProgram(value: unknown): value is WorkerStepProgram {
   return (
     !!value &&
@@ -1844,16 +1656,6 @@ function isWorkerStepProgram(value: unknown): value is WorkerStepProgram {
   );
 }
 
-function isWorkerMapDefinitionOptions(
-  value: unknown,
-): value is Omit<WorkerMapOptions, 'description' | 'concurrency'> {
-  if (!value || typeof value !== 'object' || Array.isArray(value)) {
-    return false;
-  }
-  const keys = Object.keys(value);
-  return keys.every((key) => key === 'key' || key === 'staleAfterSeconds');
-}
-
 function isWorkerConditionalStepResolver(
   value: unknown,
 ): value is WorkerConditionalStepResolver {
@@ -1917,24 +1719,34 @@ async function executeWorkerStepProgram(
     path: string[];
     outputs: RecordedStepProgramOutput[];
   },
+  workflowStep?: WorkflowStep,
 ): Promise<unknown> {
-  const currentRow: Record<string, unknown> = { ...inputRow };
+  let currentRow: Record<string, unknown> = cloneCsvAliasedRow(inputRow);
   for (const step of program.steps) {
     const stepPath = [...(recorder?.path ?? []), step.name];
-    const resolution = await executeWorkerStepResolver(
-      step.resolver,
-      currentRow,
-      ctx,
-      index,
-      recorder
-        ? {
-            ...recorder,
-            path: stepPath,
-          }
-        : undefined,
-    );
+    const runStep = async () =>
+      await executeWorkerStepResolver(
+        step.resolver,
+        currentRow,
+        ctx,
+        index,
+        recorder
+          ? {
+              ...recorder,
+              path: stepPath,
+            }
+          : undefined,
+      );
+    const resolution = workflowStep
+      ? await (
+          workflowStep.do as unknown as (
+            name: string,
+            callback: () => Promise<WorkerStepResolution>,
+          ) => Promise<WorkerStepResolution>
+        )(stepPath.join('.'), runStep)
+      : await runStep();
     const value = resolution.value;
-    currentRow[step.name] = value;
+    currentRow = cloneCsvAliasedRow(currentRow, { [step.name]: value });
     if (recorder) {
       const stepId = stepPath.join('.');
       recorder.outputs.push({
@@ -1968,7 +1780,6 @@ async function executeWorkerWaterfall(
   toolNameOrSpec: string | WorkerInlineWaterfallSpec,
   input: Record<string, unknown>,
   opts?: WorkerWaterfallOptions,
-  workflowStep?: WorkflowStep,
 ): Promise<unknown | null> {
   // Inline-spec form
   if (typeof toolNameOrSpec === 'object' && toolNameOrSpec) {
@@ -1980,38 +1791,25 @@ async function executeWorkerWaterfall(
         if (isWorkerInlineCodeStep(step)) {
           result = await step.run(input, {
             tools: {
-              execute: async (request) =>
+              execute: async (
+                requestOrKey: unknown,
+                toolId?: unknown,
+                toolInput?: unknown,
+              ) =>
                 await executeTool(
                   req,
-                  {
-                    toolId: request.tool,
-                    input: request.input,
-                    retryKey: request.id,
-                  },
-                  workflowStep,
+                  normalizeToolExecuteArgs(requestOrKey, toolId, toolInput),
                 ),
             },
-            tool: async (request) =>
-              await executeTool(
-                req,
-                {
-                  toolId: request.tool,
-                  input: request.input,
-                  retryKey: request.id,
-                },
-                workflowStep,
-              ),
+            tool: async (key, toolId, toolInput) =>
+              await executeTool(req, { id: key, toolId, input: toolInput }),
           });
         } else {
-          result = await executeTool(
-            req,
-            {
-              toolId: step.toolId,
-              input: step.mapInput(input),
-              retryKey: step.id,
-            },
-            workflowStep,
-          );
+          result = await executeTool(req, {
+            id: step.id,
+            toolId: step.toolId,
+            input: step.mapInput(input),
+          });
         }
       } catch {
         continue;
@@ -2097,11 +1895,7 @@ async function executeWorkerWaterfall(
   const providers = opts?.providers ?? [];
   if (providers.length === 0) {
     try {
-      return await executeTool(
-        req,
-        { toolId: toolName, input, retryKey: toolName },
-        workflowStep,
-      );
+      return await executeTool(req, { id: toolName, toolId: toolName, input });
     } catch {
       return null;
     }
@@ -2109,15 +1903,11 @@ async function executeWorkerWaterfall(
   let lastError: Error | null = null;
   for (const provider of providers) {
     try {
-      const result = await executeTool(
-        req,
-        {
-          toolId: toolName,
-          input: { ...input, provider },
-          retryKey: `${toolName}:${provider}`,
-        },
-        workflowStep,
-      );
+      const result = await executeTool(req, {
+        id: `${toolName}:${provider}`,
+        toolId: toolName,
+        input: { ...input, provider },
+      });
       if (resultHasContent(result)) {
         recorder.push({
           waterfallId: toolName,
@@ -2134,18 +1924,6 @@ async function executeWorkerWaterfall(
   return null;
 }
 
-function normalizePlayToolResult(value: unknown): unknown {
-  if (!isRecordLike(value)) return value;
-  if ('data' in value) return normalizePlayToolResult(value.data);
-  if ('result' in value) {
-    const normalizedResult = normalizePlayToolResult(value.result);
-    if (normalizedResult !== value.result) {
-      return { ...value, result: normalizedResult };
-    }
-  }
-  return value;
-}
-
 async function hashJson(value: unknown): Promise<string> {
   const bytes = new TextEncoder().encode(canonicalizeJson(value));
   const digest = await crypto.subtle.digest('SHA-256', bytes);
@@ -2266,18 +2044,12 @@ async function* streamCsvRowsFromBody<T extends Record<string, unknown>>(
   const flushPhysicalRowsAsObjects = (terminal: boolean): T[][] => {
     const yielded: T[][] = [];
     if (physicalRowBuffer.length === 0) return yielded;
-    let startIndex = 0;
     if (!headers) {
-      headers = physicalRowBuffer[0] ?? null;
+      headers = physicalRowBuffer.shift() ?? null;
       if (!headers) return yielded;
-      startIndex = 1;
     }
-    for (
-      let rowIndex = startIndex;
-      rowIndex < physicalRowBuffer.length;
-      rowIndex += 1
-    ) {
-      const cells = physicalRowBuffer[rowIndex]!;
+    while (physicalRowBuffer.length > 0) {
+      const cells = physicalRowBuffer.shift()!;
       const obj: Record<string, unknown> = {};
       for (let c = 0; c < headers.length; c += 1) {
         obj[headers[c]!] = cells[c] ?? '';
@@ -2288,7 +2060,6 @@ async function* streamCsvRowsFromBody<T extends Record<string, unknown>>(
         pendingChunk = [];
       }
     }
-    physicalRowBuffer.length = 0;
     if (terminal && pendingChunk.length > 0) {
       yielded.push(pendingChunk);
       pendingChunk = [];
@@ -2333,12 +2104,7 @@ async function openR2BodyStream(input: {
       return object.body;
     }
   }
-  const packagedAsset = input.req.packagedFiles?.some(
-    (file) =>
-      file.playPath === input.logicalPath ||
-      file.playPath === input.logicalPath.replace(/^\.\//, ''),
-  );
-  if (input.env.PLAY_ASSETS && packagedAsset) {
+  if (input.env.PLAY_ASSETS) {
     try {
       const text = await input.env.PLAY_ASSETS.readText(input.logicalPath);
       const bytes = new TextEncoder().encode(text);
@@ -2355,80 +2121,28 @@ async function openR2BodyStream(input: {
     }
   }
 
-  return openHarnessRangedBodyStream(input);
-}
-
-async function openHarnessRangedBodyStream(input: {
-  req: RunRequest;
-  logicalPath: string;
-  storageKey: string;
-}): Promise<ReadableStream<Uint8Array>> {
-  const headResponse = await harnessFetchStagedFile({
+  // The harness fetch path returns a real Response body backed by R2.
+  // Errors are loud: we want CI / regression failures to surface the real
+  // cause (auth, missing object, network) rather than getting squashed into a
+  // generic "R2 asset is not reachable".
+  const response = await harnessFetchStagedFile({
     executorToken: input.req.executorToken,
     storageKey: input.storageKey,
-    method: 'HEAD',
   });
-  if (headResponse.status === 404) {
+  if (response.status === 404) {
     throw new Error(
       `ctx.csv("${input.logicalPath}"): harness R2 fetch returned 404 for storageKey=${input.storageKey}. ` +
         `The staged file is missing from R2; the upload either failed silently before the run started, ` +
-        `or the storageKey threaded through the workflow params no longer matches what the harness resolves.`,
-    );
-  }
-  if (!headResponse.ok) {
-    const body = await headResponse.text().catch(() => '');
-    throw new Error(
-      `ctx.csv("${input.logicalPath}"): harness R2 metadata fetch failed ${headResponse.status}: ${body.slice(0, 400)}`,
+        `or the storageKey threaded through the workflow params no longer matches what the harness resolves.`,
     );
   }
-  const rawSize =
-    headResponse.headers.get('x-deepline-object-size') ??
-    headResponse.headers.get('content-length') ??
-    '';
-  const objectSize = Number(rawSize);
-  if (!Number.isSafeInteger(objectSize) || objectSize < 0) {
+  if (!response.ok || !response.body) {
+    const body = await response.text().catch(() => '');
     throw new Error(
-      `ctx.csv("${input.logicalPath}"): harness R2 metadata missing a valid object size for storageKey=${input.storageKey}.`,
+      `ctx.csv("${input.logicalPath}"): harness R2 fetch failed ${response.status}: ${body.slice(0, 400)}`,
     );
   }
-
-  let offset = 0;
-  return new ReadableStream<Uint8Array>({
-    async pull(controller) {
-      if (offset >= objectSize) {
-        controller.close();
-        return;
-      }
-      const length = Math.min(
-        TARGET_CSV_DECODE_CHUNK_BYTES,
-        objectSize - offset,
-      );
-      const response = await harnessFetchStagedFile({
-        executorToken: input.req.executorToken,
-        storageKey: input.storageKey,
-        range: { offset, length },
-      });
-      if (response.status === 404) {
-        throw new Error(
-          `ctx.csv("${input.logicalPath}"): harness R2 range fetch returned 404 for storageKey=${input.storageKey}.`,
-        );
-      }
-      if (!response.ok || response.status !== 206) {
-        const body = await response.text().catch(() => '');
-        throw new Error(
-          `ctx.csv("${input.logicalPath}"): harness R2 range fetch failed ${response.status}: ${body.slice(0, 400)}`,
-        );
-      }
-      const bytes = new Uint8Array(await response.arrayBuffer());
-      if (bytes.length === 0 && length > 0) {
-        throw new Error(
-          `ctx.csv("${input.logicalPath}"): harness R2 range fetch returned an empty body before EOF at offset=${offset}.`,
-        );
-      }
-      offset += bytes.length;
-      controller.enqueue(bytes);
-    },
-  });
+  return response.body;
 }
 
 /**
@@ -2454,11 +2168,11 @@ type StreamingCsvDataset<T extends Record<string, unknown>> = T[] & {
 };
 
 const MAX_MATERIALIZE_ROWS_DEFAULT = 50_000;
-const STREAMING_MAP_DEFAULT_CHUNK_SIZE = 5_000;
 
 function makeStreamingCsvDataset<T extends Record<string, unknown>>(input: {
   name: string;
   logicalPath: string;
+  renameOptions?: CsvRenameOptions;
   open: () => Promise<ReadableStream<Uint8Array> | null>;
 }): StreamingCsvDataset<T> {
   const datasetId = `csv:${input.name}`;
@@ -2472,7 +2186,12 @@ function makeStreamingCsvDataset<T extends Record<string, unknown>>(input: {
         `ctx.csv("${input.logicalPath}"): R2 asset is not reachable (no PLAYS_BUCKET binding and signed URL unavailable).`,
       );
     }
-    yield* streamCsvRowsFromBody<T>(body, Math.max(1, Math.floor(chunkSize)));
+    for await (const chunk of streamCsvRowsFromBody<T>(
+      body,
+      Math.max(1, Math.floor(chunkSize)),
+    )) {
+      yield applyCsvRenameProjection(chunk, input.renameOptions) as T[];
+    }
   }
 
   Object.defineProperty(arr, 'iterChunks', {
@@ -2629,9 +2348,12 @@ async function persistCompletedMapRows(input: {
   extraOutputFields?: string[];
 }): Promise<void> {
   if (input.rows.length === 0) return;
-  await harnessPersistCompletedSheetRows({
-    baseUrl: input.req.baseUrl,
-    executorToken: input.req.executorToken,
+  await postRuntimeApi<{
+    ok: true;
+    rowsWritten: number;
+    tableNamespace: string;
+  }>(input.req.baseUrl, input.req.executorToken, {
+    action: 'persist_completed_sheet_rows',
     playName: input.req.playName,
     tableNamespace: input.tableNamespace,
     sheetContract: requireSheetContract(input.req, input.tableNamespace),
@@ -2643,7 +2365,6 @@ async function persistCompletedMapRows(input: {
       ),
     ],
     runId: input.req.runId,
-    userEmail: input.req.userEmail,
   });
 }
 
@@ -2660,15 +2381,19 @@ async function prepareMapRows(input: {
   if (input.rows.length === 0) {
     return { inserted: 0, skipped: 0, pendingRows: [], completedRows: [] };
   }
-  const result = await harnessStartSheetDataset({
-    baseUrl: input.req.baseUrl,
-    executorToken: input.req.executorToken,
+  const result = await postRuntimeApi<{
+    inserted: number;
+    skipped: number;
+    pendingRows: Record<string, unknown>[];
+    completedRows: Record<string, unknown>[];
+    tableNamespace: string;
+  }>(input.req.baseUrl, input.req.executorToken, {
+    action: 'start_sheet_dataset',
     playName: input.req.playName,
     tableNamespace: input.tableNamespace,
     sheetContract: requireSheetContract(input.req, input.tableNamespace),
     rows: input.rows.map((row) => ({ ...row })),
     runId: input.req.runId,
-    userEmail: input.req.userEmail,
   });
   return {
     inserted: result.inserted,
@@ -2678,26 +2403,6 @@ async function prepareMapRows(input: {
   };
 }
 
-type WorkerMapExecutor = {
-  prepareRows(input: {
-    tableNamespace: string;
-    rows: Record<string, unknown>[];
-  }): ReturnType<typeof prepareMapRows>;
-  persistCompletedRows(input: {
-    tableNamespace: string;
-    rows: Record<string, unknown>[];
-    outputFields: string[];
-    extraOutputFields?: string[];
-  }): ReturnType<typeof persistCompletedMapRows>;
-};
-
-function createWorkerMapExecutor(req: RunRequest): WorkerMapExecutor {
-  return {
-    prepareRows: (input) => prepareMapRows({ req, ...input }),
-    persistCompletedRows: (input) => persistCompletedMapRows({ req, ...input }),
-  };
-}
-
 /**
  * Builds the minimal HTTP-backed ctx surface needed to run tool-basic-shaped
  * plays. NOT a full implementation of shared_libs/play-runtime/context.ts.
@@ -2705,13 +2410,8 @@ function createWorkerMapExecutor(req: RunRequest): WorkerMapExecutor {
  * Supported:
  *   - ctx.log(msg)
  *   - ctx.csv(filename | inline rows)  (calls runtime API for file resolve)
- *   - ctx.map(name, rows, opts).step(...).run(...)
- *   - ctx.tools.execute({
-   id: namespace,
-   tool: op,
-   input: input,
-   ...(opts),
- })
+ *   - ctx.map(name, rows, fields, opts)
+ *   - ctx.tools.execute(namespace, op, input, opts)
  *   - ctx.runPlay(key, playRef, input, opts)
  *
  * Not supported (will throw):
@@ -2773,7 +2473,7 @@ function releaseChildPlayConcurrency(
   inFlightByPlayName[playName] = next;
 }
 
-function createWorkerCtxFactory(
+function createMinimalWorkerCtx(
   req: RunRequest,
   emitEvent: (event: RunnerEvent) => void,
   env: WorkerEnv,
@@ -2783,9 +2483,6 @@ function createWorkerCtxFactory(
   let playCallCount = 0;
   const parentChildCalls: Record<string, number> = {};
   const inFlightChildCallsByPlayName: Record<string, number> = {};
-  const mapExecutor = createWorkerMapExecutor(req);
-  const transport = createWorkerRuntimeTransport(req);
-  const childPlayExecutor = createWorkerChildPlayExecutor({ req, transport });
   const rootGovernance = req.playCallGovernance;
   const rootRunId = rootGovernance?.rootRunId ?? req.runId;
   // Local ancestry chain that always ENDS with the currently-executing play
@@ -2829,16 +2526,88 @@ function createWorkerCtxFactory(
         candidate.mapName === name || candidate.tableNamespace === name,
     );
     const streaming = isStreamingDataset<T>(sliced);
-    const preferredChunkSize =
-      planMap?.defaultChunkSize ?? STREAMING_MAP_DEFAULT_CHUNK_SIZE;
+    // For streaming inputs we don't know the row count upfront — pass
+    // `totalRows: 0` so chooseMapChunkSize falls back to the preferred /
+    // default chunk size rather than trying to budget against an unknown.
     const rowsPerChunk = chooseMapChunkSize({
-      totalRows: streaming ? preferredChunkSize + 1 : sliced.length,
+      totalRows: streaming ? 0 : sliced.length,
       mapCount: Math.max(1, plan?.maps.length ?? 1),
       stepsPerChunk: planMap?.stepsPerChunk ?? 1,
-      preferredChunkSize,
+      preferredChunkSize: planMap?.defaultChunkSize,
       softWorkflowStepBudget: plan?.chunkPlan.softWorkflowStepBudget,
     });
     const outputFields = fieldEntries.map(([field]) => field);
+    const explicitRowKeysSeen =
+      opts?.key === undefined ? null : new Map<string, number>();
+    const resolveExplicitKeyValue = (
+      row: Record<string, unknown>,
+      index: number,
+    ): string | null => {
+      const inputRow = publicCsvInputRow(row);
+      const keyOption = opts?.key;
+      if (keyOption === undefined) {
+        return null;
+      }
+      const raw =
+        typeof keyOption === 'function'
+          ? keyOption(inputRow, index)
+          : typeof keyOption === 'string'
+            ? inputRow[keyOption]
+            : keyOption.map((fieldName) => inputRow[fieldName]);
+      const parts = Array.isArray(raw) ? raw : [raw];
+      if (parts.some((part) => part === null || part === undefined)) {
+        throw new Error(
+          `ctx.map("${name}") key returned null or undefined for row ${index}. ` +
+            'Return a non-empty string or number derived from a stable input column.',
+        );
+      }
+      const normalizedParts = parts.map((part) => {
+        if (typeof part === 'number') {
+          return Number.isFinite(part) ? String(part) : '';
+        }
+        return String(part).trim();
+      });
+      if (normalizedParts.some((part) => !part)) {
+        throw new Error(
+          `ctx.map("${name}") key returned an empty value for row ${index}. ` +
+            'Return a non-empty string or finite number derived from a stable input column.',
+        );
+      }
+      const keyValue =
+        normalizedParts.length === 1
+          ? normalizedParts[0]!
+          : JSON.stringify(normalizedParts);
+      return keyValue;
+    };
+    const resolveRowKey = (
+      row: Record<string, unknown>,
+      index: number,
+    ): string => {
+      const inputRow = publicCsvInputRow(row);
+      const explicitKeyValue = resolveExplicitKeyValue(row, index);
+      return explicitKeyValue == null
+        ? derivePlayRowIdentity(inputRow, name)
+        : derivePlayRowIdentityFromKey(explicitKeyValue, name);
+    };
+    const assertUniqueExplicitRowKeys = (
+      chunkRows: readonly Record<string, unknown>[],
+      chunkStart: number,
+    ) => {
+      if (!explicitRowKeysSeen) return;
+      for (let localIndex = 0; localIndex < chunkRows.length; localIndex += 1) {
+        const index = chunkStart + localIndex;
+        const keyValue = resolveExplicitKeyValue(chunkRows[localIndex]!, index);
+        if (keyValue == null) continue;
+        const previousIndex = explicitRowKeysSeen?.get(keyValue);
+        if (previousIndex !== undefined) {
+          throw new Error(
+            `ctx.map("${name}") key function produced duplicate value "${keyValue}" for rows ${previousIndex} and ${index}. ` +
+              'Each row must produce a unique key. Combine columns (e.g. `${row.email}|${row.company}`) or pick a column that is unique per row.',
+          );
+        }
+        explicitRowKeysSeen?.set(keyValue, index);
+      }
+    };
 
     const processChunk = async (
       chunkRows: T[],
@@ -2846,16 +2615,17 @@ function createWorkerCtxFactory(
       chunkIndex: number,
     ): Promise<WorkerMapChunkSummary<T & Record<string, unknown>>> => {
       assertNotAborted(abortSignal);
-      const prepared = await mapExecutor.prepareRows({
+      const chunkEntries = chunkRows.map((row, localIndex) => {
+        const absoluteIndex = baseOffset + chunkStart + localIndex;
+        const rowKey = resolveRowKey(row, absoluteIndex);
+        return { row, absoluteIndex, rowKey };
+      });
+      const prepared = await prepareMapRows({
+        req,
         tableNamespace: name,
-        rows: chunkRows.map((row, index) => ({
+        rows: chunkEntries.map(({ row, rowKey }) => ({
           ...row,
-          __deeplineRowKey: workerMapRowIdentity(
-            row,
-            name,
-            opts,
-            baseOffset + chunkStart + index,
-          ),
+          __deeplineRowKey: rowKey,
         })),
       });
       const pendingKeys = new Set<string>();
@@ -2865,7 +2635,7 @@ function createWorkerCtxFactory(
         const key =
           typeof row.__deeplineRowKey === 'string'
             ? row.__deeplineRowKey
-            : workerMapRowIdentity(row, name, opts);
+            : derivePlayRowIdentity(publicCsvInputRow(row), name);
         if (key) {
           pendingKeys.add(key);
           preparedKeys.add(key);
@@ -2875,20 +2645,29 @@ function createWorkerCtxFactory(
         const key =
           typeof row.__deeplineRowKey === 'string'
             ? row.__deeplineRowKey
-            : workerMapRowIdentity(row, name, opts);
+            : derivePlayRowIdentity(publicCsvInputRow(row), name);
         if (key) {
           completedKeys.add(key);
           preparedKeys.add(key);
         }
       }
-      const missingPreparedRows = chunkRows.filter((row) => {
-        const key = workerMapRowIdentity(row, name, opts);
-        return !key || !preparedKeys.has(key);
-      });
-      const rowsToExecute = chunkRows.filter((row) => {
-        const key = workerMapRowIdentity(row, name, opts);
-        return !key || pendingKeys.has(key) || !completedKeys.has(key);
-      });
+      const missingPreparedRows = chunkEntries.filter(
+        ({ rowKey }) => !preparedKeys.has(rowKey),
+      );
+      const rowsToExecuteEntries = chunkEntries.filter(
+        ({ rowKey }) => pendingKeys.has(rowKey) || !completedKeys.has(rowKey),
+      );
+      const uniqueRowsToExecuteEntries = [
+        ...new Map(
+          rowsToExecuteEntries.map((entry) => [entry.rowKey, entry]),
+        ).values(),
+      ];
+      const duplicateInputReuseCount = Math.max(
+        0,
+        chunkEntries.length -
+          new Set(chunkEntries.map((entry) => entry.rowKey)).size,
+      );
+      const rowsToExecute = uniqueRowsToExecuteEntries.map(({ row }) => row);
       const rowsInserted = prepared.inserted + missingPreparedRows.length;
       const rowsSkipped = Math.max(
         0,
@@ -2912,9 +2691,10 @@ function createWorkerCtxFactory(
               if (abortSignal?.aborted) return;
               const myIndex = idx++;
               if (myIndex >= rowsToExecute.length) return;
-              const row = rowsToExecute[myIndex]!;
-              const absoluteIndex = baseOffset + chunkStart + myIndex;
-              const enriched: Record<string, unknown> = { ...row };
+              const entry = uniqueRowsToExecuteEntries[myIndex]!;
+              const row = entry.row;
+              const absoluteIndex = entry.absoluteIndex;
+              const enriched: Record<string, unknown> = cloneCsvAliasedRow(row);
               const fieldOutputs: Record<string, unknown> = {};
               const cellMetaPatch: Record<
                 string,
@@ -2925,25 +2705,35 @@ function createWorkerCtxFactory(
               const rowCtx = {
                 ...(ctx as Record<string, unknown>),
                 tool: async (
-                  request: WorkerToolExecutionRequest,
+                  key: string,
+                  toolId: string,
+                  input: Record<string, unknown>,
                 ): Promise<unknown> => {
                   assertNotAborted(abortSignal);
                   return await toolBatchScheduler.execute(
-                    request.id,
-                    request.tool,
-                    request.input,
+                    key,
+                    toolId,
+                    input,
                     workflowStep,
                   );
                 },
                 tools: {
                   ...((ctx as { tools?: Record<string, unknown> }).tools ?? {}),
                   execute: async (
-                    request: WorkerToolExecutionRequest,
+                    requestOrKey: unknown,
+                    toolId?: unknown,
+                    input?: unknown,
+                    _opts?: { description?: string },
                   ): Promise<unknown> => {
                     assertNotAborted(abortSignal);
+                    const request = normalizeToolExecuteArgs(
+                      requestOrKey,
+                      toolId,
+                      input,
+                    );
                     return await toolBatchScheduler.execute(
                       request.id,
-                      request.tool,
+                      request.toolId,
                       request.input,
                       workflowStep,
                     );
@@ -2960,7 +2750,6 @@ function createWorkerCtxFactory(
                     toolNameOrSpec,
                     waterfallInput,
                     waterfallOpts,
-                    workflowStep,
                   ),
               };
               for (const [key, value] of fieldEntries) {
@@ -3010,13 +2799,33 @@ function createWorkerCtxFactory(
           })(),
         );
       }
-      await Promise.all(workers);
-      if (executedRows.length > 0) {
-        await mapExecutor.persistCompletedRows({
+      const persistExecutedRows = async () => {
+        const rowsToPersist = executedRows
+          .map((row, executedIndex) =>
+            row
+              ? {
+                  row,
+                  executedIndex,
+                }
+              : null,
+          )
+          .filter(
+            (
+              entry,
+            ): entry is {
+              row: T & Record<string, unknown>;
+              executedIndex: number;
+            } => entry !== null,
+          );
+        if (rowsToPersist.length === 0) {
+          return;
+        }
+        await persistCompletedMapRows({
+          req,
           tableNamespace: name,
           outputFields,
           extraOutputFields: Array.from(generatedOutputFields),
-          rows: executedRows.map((row, executedIndex) => ({
+          rows: rowsToPersist.map(({ row, executedIndex }) => ({
             ...row,
             ...(executedCellMetaPatches[executedIndex]
               ? {
@@ -3024,22 +2833,29 @@ function createWorkerCtxFactory(
                     executedCellMetaPatches[executedIndex],
                 }
               : {}),
-            __deeplineRowKey: workerMapRowIdentity(
-              rowsToExecute[executedIndex]!,
-              name,
-              opts,
-            ),
+            __deeplineRowKey:
+              uniqueRowsToExecuteEntries[executedIndex]!.rowKey,
           })),
         });
+      };
+      const workerResults = await Promise.allSettled(workers);
+      await persistExecutedRows();
+      const rejectedWorker = workerResults.find(
+        (result): result is PromiseRejectedResult =>
+          result.status === 'rejected',
+      );
+      if (rejectedWorker) {
+        throw rejectedWorker.reason;
       }
       const resultByKey = new Map<string, T & Record<string, unknown>>();
       for (const completedRow of prepared.completedRows) {
         const key =
           typeof completedRow.__deeplineRowKey === 'string'
             ? completedRow.__deeplineRowKey
-            : workerMapRowIdentity(completedRow, name, opts);
+            : derivePlayRowIdentity(publicCsvInputRow(completedRow), name);
         if (key) {
-          const { __deeplineRowKey: _rowKey, ...cleanedRow } = completedRow;
+          const { __deeplineRowKey: _rowKey, ...cleanedRow } =
+            publicCsvInputRow(completedRow);
           void _rowKey;
           resultByKey.set(key, cleanedRow as T & Record<string, unknown>);
         }
@@ -3050,17 +2866,13 @@ function createWorkerCtxFactory(
         executedIndex += 1
       ) {
         const executedRow = executedRows[executedIndex]!;
-        const key = workerMapRowIdentity(
-          rowsToExecute[executedIndex]!,
-          name,
-          opts,
-        );
+        const key = uniqueRowsToExecuteEntries[executedIndex]!.rowKey;
         if (key) resultByKey.set(key, executedRow);
       }
       const out = chunkRows
-        .map((row) => {
-          const key = workerMapRowIdentity(row, name, opts);
-          return key ? resultByKey.get(key) : undefined;
+        .map((_row, index) => {
+          const key = chunkEntries[index]!.rowKey;
+          return resultByKey.get(key);
         })
         .filter((row): row is T & Record<string, unknown> => Boolean(row));
       return {
@@ -3070,18 +2882,20 @@ function createWorkerCtxFactory(
         rowsRead: chunkRows.length,
         rowsWritten: out.length,
         rowsExecuted: executedRows.length,
-        rowsCached: prepared.completedRows.length,
+        rowsCached: Math.max(0, out.length - executedRows.length),
+        rowsDuplicateReused: duplicateInputReuseCount,
         rowsInserted,
         rowsSkipped,
         outputDatasetId: `map:${name}`,
         hash: await hashJson(out),
-        preview: toWorkflowSerializableValue(out.slice(0, 10)),
+        preview: toWorkflowSerializableValue(out.slice(0, 5)),
       };
     };
 
     const out: Array<T & Record<string, unknown>> = [];
     let totalRowsExecuted = 0;
     let totalRowsCached = 0;
+    let totalRowsDuplicateReused = 0;
     let totalRowsInserted = 0;
     let totalRowsSkipped = 0;
 
@@ -3124,6 +2938,17 @@ function createWorkerCtxFactory(
       return makeWorkerDataset(name, out, {
         count: totalRowsWritten,
         cacheSummary,
+        workProgress: {
+          total: totalRowsWritten,
+          executed: totalRowsExecuted,
+          reused: totalRowsCached,
+          skipped: totalRowsCached,
+          pending: 0,
+          failed: 0,
+          ...(totalRowsDuplicateReused > 0
+            ? { duplicates: { exact: totalRowsDuplicateReused } }
+            : {}),
+        },
       });
     };
 
@@ -3135,6 +2960,7 @@ function createWorkerCtxFactory(
       for await (const chunkRows of streamingDataset.iterChunks(rowsPerChunk)) {
         assertNotAborted(abortSignal);
         if (chunkRows.length === 0) continue;
+        assertUniqueExplicitRowKeys(chunkRows, chunkStart);
         const chunkResult = await runChunkStep(
           chunkRows,
           chunkStart,
@@ -3143,6 +2969,7 @@ function createWorkerCtxFactory(
         totalRowsWritten += chunkResult.rowsWritten;
         totalRowsExecuted += chunkResult.rowsExecuted;
         totalRowsCached += chunkResult.rowsCached;
+        totalRowsDuplicateReused += chunkResult.rowsDuplicateReused;
         totalRowsInserted += chunkResult.rowsInserted;
         totalRowsSkipped += chunkResult.rowsSkipped;
         if (out.length < 10) {
@@ -3161,10 +2988,12 @@ function createWorkerCtxFactory(
         const end = Math.min(sliced.length, start + rowsPerChunk);
         const chunkRows = sliced.slice(start, end);
         const chunkIndex = Math.floor(start / rowsPerChunk);
+        assertUniqueExplicitRowKeys(chunkRows, start);
         const chunkResult = await runChunkStep(chunkRows, start, chunkIndex);
         totalRowsWritten += chunkResult.rowsWritten;
         totalRowsExecuted += chunkResult.rowsExecuted;
         totalRowsCached += chunkResult.rowsCached;
+        totalRowsDuplicateReused += chunkResult.rowsDuplicateReused;
         totalRowsInserted += chunkResult.rowsInserted;
         totalRowsSkipped += chunkResult.rowsSkipped;
         if (out.length < 10) {
@@ -3174,9 +3003,11 @@ function createWorkerCtxFactory(
       return finalize(totalRowsWritten);
     }
 
+    assertUniqueExplicitRowKeys(sliced, 0);
     const chunkResult = await runChunkStep(sliced, 0, 0);
     totalRowsExecuted = chunkResult.rowsExecuted;
     totalRowsCached = chunkResult.rowsCached;
+    totalRowsDuplicateReused = chunkResult.rowsDuplicateReused;
     totalRowsInserted = chunkResult.rowsInserted;
     totalRowsSkipped = chunkResult.rowsSkipped;
     out.push(...chunkResult.preview);
@@ -3192,10 +3023,6 @@ function createWorkerCtxFactory(
     constructor(
       private readonly name: string,
       private readonly rows: T[],
-      private readonly mapOptions?: Omit<
-        WorkerMapOptions,
-        'description' | 'concurrency'
-      >,
     ) {}
 
     step(name: string, resolver: WorkerStepProgramStep['resolver']): this {
@@ -3207,23 +3034,10 @@ function createWorkerCtxFactory(
     }
 
     run(opts?: WorkerMapOptions): Promise<unknown> {
-      if (
-        opts &&
-        Object.keys(opts).some(
-          (optionKey) => optionKey !== 'description' && optionKey !== 'concurrency',
-        )
-      ) {
-        throw new Error(
-          'ctx.map(...).run() only accepts description and concurrency.',
-        );
-      }
       const fields = Object.fromEntries(
         this.program.steps.map((step) => [step.name, step.resolver]),
       );
-      return runMap(this.name, this.rows, fields, {
-        ...this.mapOptions,
-        ...opts,
-      });
+      return runMap(this.name, this.rows, fields, opts);
     }
   }
 
@@ -3246,36 +3060,66 @@ function createWorkerCtxFactory(
     },
     async step<T>(name: string, callback: () => Promise<T> | T): Promise<T> {
       assertNotAborted(abortSignal);
-      if (!workflowStep) {
-        return await callback();
+      if (!name.trim()) {
+        throw new Error('ctx.step(name, callback) requires a name.');
       }
-      return await (
-        workflowStep.do as unknown as (
-          name: string,
-          callback: () => Promise<T>,
-        ) => Promise<T>
-      )(name, async () => {
-        assertNotAborted(abortSignal);
-        return await callback();
-      });
+      // Static pipeline JS blocks are already Workflow steps in the Workers
+      // backend. Nesting another `step.do` here can leave preview runs parked
+      // inside the JS stage before they reach subsequent event waits.
+      return await callback();
+    },
+    async runSteps<T>(
+      program: WorkerStepProgram,
+      input: Record<string, unknown>,
+      opts?: { description?: string },
+    ): Promise<T> {
+      assertNotAborted(abortSignal);
+      if (!isWorkerStepProgram(program)) {
+        throw new Error('ctx.runSteps(program, input) requires steps().');
+      }
+      if (opts?.description) {
+        emitEvent({
+          type: 'log',
+          level: 'info',
+          message: String(opts.description),
+          ts: nowMs(),
+        });
+      }
+      return (await executeWorkerStepProgram(
+        program,
+        input,
+        ctx,
+        0,
+        undefined,
+        workflowStep,
+      )) as T;
     },
     async csv<T extends Record<string, unknown> = Record<string, unknown>>(
       arg: unknown,
+      options?: CsvRenameOptions,
     ): Promise<T[]> {
       if (Array.isArray(arg)) {
         // Inline rows passed at call site — already in memory, keep the
         // legacy array-backed dataset shape.
-        return makeWorkerDataset('csv', arg as T[], {
-          datasetKind: 'csv',
-        }) as unknown as T[];
+        return makeWorkerDataset(
+          'csv',
+          applyCsvRenameProjection(arg as T[], options),
+          {
+            datasetKind: 'csv',
+          },
+        ) as unknown as T[];
       }
       const filename = String(arg ?? '');
       if (req.inlineCsv && filename === req.inlineCsv.name) {
         // Inline CSV pre-staged by the dispatcher (small files <1 MiB). Already
         // in memory; no streaming needed.
-        return makeWorkerDataset('csv', req.inlineCsv.rows as T[], {
-          datasetKind: 'csv',
-        }) as unknown as T[];
+        return makeWorkerDataset(
+          'csv',
+          applyCsvRenameProjection(req.inlineCsv.rows as T[], options),
+          {
+            datasetKind: 'csv',
+          },
+        ) as unknown as T[];
       }
       // Resolution order: explicit inputR2Keys (runtime input) → packaged
       // files (relative-path imports bundled with the play artifact).
@@ -3303,6 +3147,7 @@ function createWorkerCtxFactory(
       return makeStreamingCsvDataset<T>({
         name: filename,
         logicalPath: filename,
+        renameOptions: options,
         open: () =>
           openR2BodyStream({
             req,
@@ -3327,18 +3172,10 @@ function createWorkerCtxFactory(
               ) => Promise<unknown> | unknown)
           >
         | WorkerStepProgram,
-      opts?: { description?: string; concurrency?: number },
+      opts?: WorkerMapOptions,
     ): unknown {
-      if (
-        arguments.length <= 2 ||
-        fieldsDef === undefined ||
-        isWorkerMapDefinitionOptions(fieldsDef)
-      ) {
-        return new WorkerMapBuilder(
-          name,
-          rows,
-          fieldsDef as Omit<WorkerMapOptions, 'description' | 'concurrency'>,
-        );
+      if (arguments.length <= 2 || fieldsDef === undefined) {
+        return new WorkerMapBuilder(name, rows);
       }
       if (isWorkerStepProgram(fieldsDef)) {
         const fields = Object.fromEntries(
@@ -3346,7 +3183,9 @@ function createWorkerCtxFactory(
         );
         return runMap(name, rows, fields, opts);
       }
-      throw new Error('ctx.map() accepts key, rows, and map options only.');
+      throw new Error(
+        'ctx.map(key, rows, fields, options) was removed. Use ctx.map(key, rows).step(...).run(options).',
+      );
       /*
       const sliced = rows;
       const baseOffset = 0;
@@ -3357,13 +3196,14 @@ function createWorkerCtxFactory(
           candidate.mapName === name || candidate.tableNamespace === name,
       );
       const streaming = isStreamingDataset<T>(sliced);
-      const preferredChunkSize =
-        planMap?.defaultChunkSize ?? STREAMING_MAP_DEFAULT_CHUNK_SIZE;
+      // For streaming inputs we don't know the row count upfront — pass
+      // `totalRows: 0` so chooseMapChunkSize falls back to the preferred /
+      // default chunk size rather than trying to budget against an unknown.
       const rowsPerChunk = chooseMapChunkSize({
-        totalRows: streaming ? preferredChunkSize + 1 : sliced.length,
+        totalRows: streaming ? 0 : sliced.length,
         mapCount: Math.max(1, plan?.maps.length ?? 1),
         stepsPerChunk: planMap?.stepsPerChunk ?? 1,
-        preferredChunkSize,
+        preferredChunkSize: planMap?.defaultChunkSize,
         softWorkflowStepBudget: plan?.chunkPlan.softWorkflowStepBudget,
       });
       const outputFields = fieldEntries.map(([field]) => field);
@@ -3387,7 +3227,7 @@ function createWorkerCtxFactory(
         const completedKeys = new Set<string>();
         const preparedKeys = new Set<string>();
         for (const row of prepared.pendingRows) {
-          const key = derivePlayRowIdentity(row, name);
+          const key = derivePlayRowIdentity(publicCsvInputRow(row), name);
           if (key) {
             pendingKeys.add(key);
             preparedKeys.add(key);
@@ -3397,18 +3237,18 @@ function createWorkerCtxFactory(
           const key =
             typeof row.__deeplineRowKey === 'string'
               ? row.__deeplineRowKey
-              : derivePlayRowIdentity(row, name);
+              : derivePlayRowIdentity(publicCsvInputRow(row), name);
           if (key) {
             completedKeys.add(key);
             preparedKeys.add(key);
           }
         }
         const missingPreparedRows = chunkRows.filter((row) => {
-          const key = derivePlayRowIdentity(row, name);
+          const key = derivePlayRowIdentity(publicCsvInputRow(row), name);
           return !key || !preparedKeys.has(key);
         });
         const rowsToExecute = chunkRows.filter((row) => {
-          const key = derivePlayRowIdentity(row, name);
+          const key = derivePlayRowIdentity(publicCsvInputRow(row), name);
           return !key || pendingKeys.has(key) || !completedKeys.has(key);
         });
         const rowsInserted = prepared.inserted + missingPreparedRows.length;
@@ -3432,7 +3272,7 @@ function createWorkerCtxFactory(
                 if (myIndex >= rowsToExecute.length) return;
                 const row = rowsToExecute[myIndex]!;
                 const absoluteIndex = baseOffset + chunkStart + myIndex;
-                const enriched: Record<string, unknown> = { ...row };
+                const enriched: Record<string, unknown> = cloneCsvAliasedRow(row);
                 const fieldOutputs: Record<string, unknown> = {};
                 const waterfallOutputs: RecordedWaterfallOutput[] = [];
                 const rowCtx = {
@@ -3448,7 +3288,6 @@ function createWorkerCtxFactory(
                       toolNameOrSpec,
                       waterfallInput,
                       waterfallOpts,
-                      workflowStep,
                     ),
                 };
                 for (const [key, value] of fieldEntries) {
@@ -3490,7 +3329,7 @@ function createWorkerCtxFactory(
             rows: executedRows.map((row, executedIndex) => ({
               ...row,
               __deeplineRowKey: derivePlayRowIdentity(
-                rowsToExecute[executedIndex]!,
+                publicCsvInputRow(rowsToExecute[executedIndex]!),
                 name,
               ),
             })),
@@ -3501,9 +3340,10 @@ function createWorkerCtxFactory(
           const key =
             typeof completedRow.__deeplineRowKey === 'string'
               ? completedRow.__deeplineRowKey
-              : derivePlayRowIdentity(completedRow, name);
+              : derivePlayRowIdentity(publicCsvInputRow(completedRow), name);
           if (key) {
-            const { __deeplineRowKey: _rowKey, ...cleanedRow } = completedRow;
+            const { __deeplineRowKey: _rowKey, ...cleanedRow } =
+              publicCsvInputRow(completedRow);
             void _rowKey;
             resultByKey.set(key, cleanedRow as T & Record<string, unknown>);
           }
@@ -3515,14 +3355,14 @@ function createWorkerCtxFactory(
         ) {
           const executedRow = executedRows[executedIndex]!;
           const key = derivePlayRowIdentity(
-            rowsToExecute[executedIndex]!,
+            publicCsvInputRow(rowsToExecute[executedIndex]!),
             name,
           );
           if (key) resultByKey.set(key, executedRow);
         }
         const out = chunkRows
           .map((row) => {
-            const key = derivePlayRowIdentity(row, name);
+            const key = derivePlayRowIdentity(publicCsvInputRow(row), name);
             return key ? resultByKey.get(key) : undefined;
           })
           .filter((row): row is T & Record<string, unknown> => Boolean(row));
@@ -3538,7 +3378,7 @@ function createWorkerCtxFactory(
           rowsSkipped,
           outputDatasetId: `map:${name}`,
           hash: await hashJson(out),
-          preview: toWorkflowSerializableValue(out.slice(0, 10)),
+          preview: toWorkflowSerializableValue(out.slice(0, 5)),
         };
       };
 
@@ -3587,6 +3427,14 @@ function createWorkerCtxFactory(
         return makeWorkerDataset(name, out, {
           count: totalRowsWritten,
           cacheSummary,
+          workProgress: {
+            total: totalRowsWritten,
+            executed: totalRowsExecuted,
+            reused: totalRowsCached,
+            skipped: totalRowsCached,
+            pending: 0,
+            failed: 0,
+          },
         });
       };
 
@@ -3653,28 +3501,25 @@ function createWorkerCtxFactory(
       return finalize(chunkResult.rowsWritten);
       */
     },
-    tool: async (request: WorkerToolExecutionRequest): Promise<unknown> => {
+    tool: async (
+      key: string,
+      toolId: string,
+      input: Record<string, unknown>,
+    ): Promise<unknown> => {
       assertNotAborted(abortSignal);
-      return executeTool(
-        req,
-        {
-          toolId: request.tool,
-          input: request.input,
-          retryKey: request.id,
-        },
-        workflowStep,
-      );
+      return executeTool(req, { id: key, toolId, input }, workflowStep);
     },
     tools: {
-      async execute(request: WorkerToolExecutionRequest): Promise<unknown> {
+      async execute(
+        requestOrKey: unknown,
+        toolId?: unknown,
+        input?: unknown,
+        _opts?: { description?: string },
+      ): Promise<unknown> {
         assertNotAborted(abortSignal);
         return executeTool(
           req,
-          {
-            toolId: request.tool,
-            input: request.input,
-            retryKey: request.id,
-          },
+          normalizeToolExecuteArgs(requestOrKey, toolId, input),
           workflowStep,
         );
       },
@@ -3702,14 +3547,7 @@ function createWorkerCtxFactory(
       input: Record<string, unknown>,
       opts?: WorkerWaterfallOptions,
     ): Promise<unknown | null> {
-      return executeWorkerWaterfall(
-        req,
-        [],
-        toolNameOrSpec,
-        input,
-        opts,
-        workflowStep,
-      );
+      return executeWorkerWaterfall(req, [], toolNameOrSpec, input, opts);
     },
     async sleep(ms: number): Promise<void> {
       assertNotAborted(abortSignal);
@@ -3798,33 +3636,33 @@ function createWorkerCtxFactory(
       }
       try {
         const childSubmitStartedAt = nowMs();
-        let started: Awaited<
-          ReturnType<typeof submitChildPlayThroughCoordinator>
-        >;
+        let started: { workflowId?: string; runId?: string; error?: unknown };
         try {
-          started = await childPlayExecutor.submit({
-            name: resolvedName,
-            input: isRecord(input) ? input : {},
-            orgId: req.orgId,
-            callbackBaseUrl: req.baseUrl,
-            parentExecutorToken: req.executorToken,
-            userEmail: req.userEmail ?? '',
-            profile: 'workers_edge',
-            manifest: childManifest,
-            childPlayManifests: req.childPlayManifests ?? null,
-            internalRunPlay: {
-              rootRunId,
-              parentRunId: req.runId,
-              parentPlayName: req.playName,
-              key: normalizedKey,
-              // Per the lineage validator: ancestry tail must equal the
-              // executor token's play name (the parent making this call).
-              ancestryPlayIds,
-              callDepth: nextDepth,
-              description:
-                typeof options?.description === 'string'
-                  ? options.description
-                  : null,
+          started = await submitChildPlayThroughCoordinator({
+            req,
+            body: {
+              name: resolvedName,
+              input: isRecord(input) ? input : {},
+              orgId: req.orgId,
+              parentExecutorToken: req.executorToken,
+              userEmail: req.userEmail ?? '',
+              profile: 'workers_edge',
+              manifest: childManifest,
+              childPlayManifests: req.childPlayManifests ?? null,
+              internalRunPlay: {
+                rootRunId,
+                parentRunId: req.runId,
+                parentPlayName: req.playName,
+                key: normalizedKey,
+                // Per the lineage validator: ancestry tail must equal the
+                // executor token's play name (the parent making this call).
+                ancestryPlayIds,
+                callDepth: nextDepth,
+                description:
+                  typeof options?.description === 'string'
+                    ? options.description
+                    : null,
+              },
             },
           });
         } catch (error) {
@@ -3870,112 +3708,12 @@ function createWorkerCtxFactory(
           fanoutIndex: nextParentCalls - 1,
           ms: nowMs() - childSubmitStartedAt,
           status: 'ok',
-          mode:
-            typeof started.mode === 'string' ? started.mode : 'workflow_child',
         });
-        const terminalStatus =
-          typeof started.status === 'string'
-            ? started.status.toLowerCase()
-            : '';
-        if (started.mode === 'inline_dynamic_worker') {
-          const timingSummary =
-            Array.isArray(started.timings) && started.timings.length > 0
-              ? started.timings
-                  .map(
-                    (timing) =>
-                      `${timing.phase.replace('coordinator.inline_child_', '')}:${timing.ms}ms`,
-                  )
-                  .join(' ')
-              : 'timings:none';
-          emitEvent({
-            type: 'log',
-            level: terminalStatus === 'failed' ? 'error' : 'info',
-            message: `Inline child ${resolvedName} (${workflowId}) boundary=${terminalStatus || 'submitted'} ${timingSummary}`,
-            ts: nowMs(),
-          });
-          const childLogs = Array.isArray(started.logs)
-            ? started.logs.filter((line) => typeof line === 'string')
-            : [];
-          for (const line of childLogs.slice(0, 24)) {
-            emitEvent({
-              type: 'log',
-              level: 'info',
-              message: `  ${resolvedName}> ${line}`,
-              ts: nowMs(),
-            });
-          }
-          if (childLogs.length > 24) {
-            emitEvent({
-              type: 'log',
-              level: 'info',
-              message: `  ${resolvedName}> ... ${childLogs.length - 24} more inline child log lines omitted`,
-              ts: nowMs(),
-            });
-          }
-        }
-        if (terminalStatus === 'completed') {
-          console.info('[play.runtime.span]', {
-            event: 'play.runtime.span',
-            phase: 'child_wait',
-            runId: req.runId,
-            parentRunId: req.runId,
-            childRunId: workflowId,
-            playName: resolvedName,
-            graphHash: req.graphHash ?? null,
-            depth: nextDepth,
-            fanoutIndex: nextParentCalls - 1,
-            ms: 0,
-            status: 'ok',
-            mode:
-              typeof started.mode === 'string'
-                ? started.mode
-                : 'inline_terminal',
-          });
-          emitEvent({
-            type: 'log',
-            level: 'info',
-            message: `Completed child play ${resolvedName} (${normalizedKey})`,
-            ts: nowMs(),
-          });
-          return 'output' in started ? started.output : started.result;
-        }
-        if (terminalStatus === 'failed') {
-          const inlineError = isRecord(started.error) ? started.error : null;
-          const message =
-            (typeof inlineError?.message === 'string' &&
-              inlineError.message.trim()) ||
-            (typeof started.error === 'string' && started.error.trim()) ||
-            `Child play ${resolvedName} (${workflowId}) failed.`;
-          console.info('[play.runtime.span]', {
-            event: 'play.runtime.span',
-            phase: 'child_wait',
-            runId: req.runId,
-            parentRunId: req.runId,
-            childRunId: workflowId,
-            playName: resolvedName,
-            graphHash: req.graphHash ?? null,
-            depth: nextDepth,
-            fanoutIndex: nextParentCalls - 1,
-            ms: 0,
-            status: 'failed',
-            mode:
-              typeof started.mode === 'string'
-                ? started.mode
-                : 'inline_terminal',
-            errorCode: 'CHILD_INLINE_FAILED',
-          });
-          emitEvent({
-            type: 'log',
-            level: 'error',
-            message: `Inline child ${resolvedName} (${workflowId}) failed: ${message}`,
-            ts: nowMs(),
-          });
-          throw new Error(message);
-        }
         const childWaitStartedAt = nowMs();
         let result: unknown;
         try {
-          result = await childPlayExecutor.waitTerminal({
+          result = await waitForChildPlayTerminalEvent({
+            req,
             workflowStep,
             workflowId,
             playName: resolvedName,
@@ -4053,11 +3791,11 @@ function createWorkerCtxFactory(
       const event = (await (
         workflowStep.waitForEvent as unknown as (
           name: string,
-          options: { type: string; timeout: number },
+          options: { type: string; timeout: string },
         ) => Promise<{ payload: unknown }>
       )(`wait_for_event:${workflowEventType(eventType)}`, {
         type: workflowEventType(eventType),
-        timeout: timeoutMs,
+        timeout: workflowTimeoutFromMs(timeoutMs),
       })) as { payload: unknown };
       return event.payload ?? null;
     },
@@ -4086,9 +3824,12 @@ async function handleRun(request: Request, env: WorkerEnv): Promise<Response> {
   (async () => {
     try {
       installProcessExitTrap();
+      const runPrefix = `[deepline-run:${req.runId}]`;
       captureCoordinatorBinding(env);
+      captureRuntimeApiBinding(env);
       captureHarnessBinding(env);
-      const ctx = createWorkerCtxFactory(req, emit, env);
+      await probeHarnessOnce(env, runPrefix);
+      const ctx = createMinimalWorkerCtx(req, emit, env);
       const result = await (
         playFn as (
           ctx: unknown,
@@ -4142,8 +3883,6 @@ async function executeRunRequest(
   workflowStep?: WorkflowStep,
   options?: {
     persistResultDatasets?: boolean;
-    signalParentTerminal?: boolean;
-    waitUntil?: (promise: Promise<unknown>) => void;
     /**
      * Cooperative cancellation token. CF Workflows surfaces termination as a
      * thrown error from any in-progress step; the harness catches that, flips
@@ -4156,7 +3895,6 @@ async function executeRunRequest(
   const startedAt = nowMs();
   const abortController = options?.abortController ?? new AbortController();
   const abortSignal = abortController.signal;
-  const transport = createWorkerRuntimeTransport(req);
   // Maintain a rolling buffer of log lines emitted during the run. This is
   // what the play-page UI consumes via Convex polling + diffPlayRunStreamEvents
   // → play.run.log SSE events. Without periodic flushing, the play page only
@@ -4184,15 +3922,14 @@ async function executeRunRequest(
       .catch(() => undefined)
       .then(async () => {
         try {
-          await transport.postRuntimeApi(
-            runtimeRunActions.updateStatus({
-              playId: req.runId,
-              status: 'running',
-              runtimeBackend: 'cf_workflows_dynamic_worker',
-              liveLogs: snapshot,
-              lastCheckpointAt: now,
-            }),
-          );
+          await postRuntimeApi(req.baseUrl, req.executorToken, {
+            action: 'update_run_status',
+            playId: req.runId,
+            status: 'running',
+            runtimeBackend: 'cf_workflows_dynamic_worker',
+            liveLogs: snapshot,
+            lastCheckpointAt: now,
+          });
         } catch {
           // Best-effort; the terminal update still carries the final logs.
         }
@@ -4214,7 +3951,7 @@ async function executeRunRequest(
     emit(event);
   };
 
-  const ctx = createWorkerCtxFactory(
+  const ctx = createMinimalWorkerCtx(
     req,
     wrappedEmit,
     env,
@@ -4222,105 +3959,48 @@ async function executeRunRequest(
     abortSignal,
   );
   try {
-    const playStartedAt = nowMs();
     const result = await (
       playFn as (
         ctx: unknown,
         input: Record<string, unknown>,
       ) => Promise<unknown>
     )(ctx, req.runtimeInput);
-    recordDynamicWorkerPerfTrace({
-      env,
-      runId: req.runId,
-      phase: 'dynamic_worker.play_fn',
-      ms: nowMs() - playStartedAt,
-      graphHash: req.graphHash ?? null,
-      waitUntil: options?.waitUntil,
-    });
     const serializedResult = serializePlayReturnValue(result);
     if (options?.persistResultDatasets) {
       await liveLogFlushInFlight.catch(() => undefined);
-      const persistStartedAt = nowMs();
       await persistResultDatasets(req, serializedResult);
-      recordDynamicWorkerPerfTrace({
-        env,
-        runId: req.runId,
-        phase: 'dynamic_worker.persist_result_datasets',
-        ms: nowMs() - persistStartedAt,
-        graphHash: req.graphHash ?? null,
-        waitUntil: options?.waitUntil,
+      const terminalResult = trimResultForStatus(serializedResult);
+      await postRuntimeApiBestEffort(req.baseUrl, req.executorToken, {
+        action: 'update_run_status',
+        playId: req.runId,
+        status: 'completed',
+        result: terminalResult,
+        runtimeBackend: 'cf_workflows_dynamic_worker',
+        waitKind: null,
+        waitUntil: null,
+        activeBoundaryId: null,
+        liveLogs,
+        lastCheckpointAt: nowMs(),
       });
-      const billingCapMustBlockTerminal =
-        extractMaxCreditsPerRun(req.contractSnapshot) !== null;
-      const finalizeBilling = () =>
-        finalizeWorkerComputeBilling({
-          req,
-          transport,
-          success: true,
-          actionEstimate: 4,
-        });
-      if (billingCapMustBlockTerminal) {
-        await finalizeBilling();
-      }
-      const terminalResult = trimResultForStatus(serializedResult) as
-        | Record<string, unknown>
-        | null;
-      const terminalStartedAt = nowMs();
-      await transport.postRuntimeApiBestEffort(
-        runtimeRunActions.updateStatus({
-          playId: req.runId,
-          status: 'completed',
-          result: terminalResult,
-          runtimeBackend: 'cf_workflows_dynamic_worker',
-          liveLogs,
-          lastCheckpointAt: nowMs(),
-        }),
-      );
-      recordDynamicWorkerPerfTrace({
-        env,
-        runId: req.runId,
-        phase: 'dynamic_worker.terminal_status_update',
-        ms: nowMs() - terminalStartedAt,
-        graphHash: req.graphHash ?? null,
-        waitUntil: options?.waitUntil,
+      await finalizeWorkerComputeBilling({
+        req,
+        success: true,
+        actionEstimate: 4,
       });
-      if (!billingCapMustBlockTerminal) {
-        const finalizeBillingPromise = finalizeBilling();
-        if (options?.waitUntil) {
-          options.waitUntil(
-            finalizeBillingPromise.catch((finalizeError) => {
-              console.error(
-                `[play-harness] non-fatal compute billing finalize failed runId=${req.runId}: ${
-                  finalizeError instanceof Error
-                    ? finalizeError.message
-                    : String(finalizeError)
-                }`,
-              );
-            }),
-          );
-        } else {
-          await finalizeBillingPromise;
-        }
-      }
-    }
-    if (options?.signalParentTerminal !== false) {
-      await transport
-        .signalParentTerminal({
-          status: 'completed',
-          result: trimResultForStatus(serializedResult) as Record<
-            string,
-            unknown
-          >,
-        })
-        .catch((error) => {
-          console.error(
-            `[play-harness] non-fatal parent completion signal failed runId=${req.runId}: ${
-              error instanceof Error ? error.message : String(error)
-            }`,
-          );
-        });
     }
+    await signalParentPlayTerminal({
+      req,
+      status: 'completed',
+      result: trimResultForStatus(serializedResult) as Record<string, unknown>,
+    }).catch((error) => {
+      console.error(
+        `[play-harness] non-fatal parent completion signal failed runId=${req.runId}: ${
+          error instanceof Error ? error.message : String(error)
+        }`,
+      );
+    });
     return {
+      playName: req.playName,
       result: serializedResult,
       outputRows: inferOutputRows(serializedResult),
       durationMs: nowMs() - startedAt,
@@ -4337,23 +4017,23 @@ async function executeRunRequest(
     const message = error instanceof Error ? error.message : String(error);
     if (options?.persistResultDatasets) {
       await liveLogFlushInFlight.catch(() => undefined);
-      await transport.postRuntimeApiBestEffort(
-        runtimeRunActions.updateStatus({
-          playId: req.runId,
-          status: aborted ? 'cancelled' : 'failed',
-          error: message,
-          runtimeBackend: 'cf_workflows_dynamic_worker',
-          liveLogs,
-          lastCheckpointAt: nowMs(),
-        }),
-      );
-      const finalizeBillingPromise = finalizeWorkerComputeBilling({
+      await postRuntimeApiBestEffort(req.baseUrl, req.executorToken, {
+        action: 'update_run_status',
+        playId: req.runId,
+        status: aborted ? 'cancelled' : 'failed',
+        error: message,
+        runtimeBackend: 'cf_workflows_dynamic_worker',
+        waitKind: null,
+        waitUntil: null,
+        activeBoundaryId: null,
+        liveLogs,
+        lastCheckpointAt: nowMs(),
+      });
+      await finalizeWorkerComputeBilling({
         req,
-        transport,
         success: false,
         actionEstimate: 4,
-      });
-      const logFinalizeError = (finalizeError: unknown) => {
+      }).catch((finalizeError) => {
         console.error(
           `[play-harness] non-fatal compute billing finalize failed runId=${req.runId}: ${
             finalizeError instanceof Error
@@ -4361,21 +4041,13 @@ async function executeRunRequest(
               : String(finalizeError)
           }`,
         );
-      };
-      if (options?.waitUntil) {
-        options.waitUntil(finalizeBillingPromise.catch(logFinalizeError));
-      } else {
-        await finalizeBillingPromise.catch(logFinalizeError);
-      }
-    }
-    if (options?.signalParentTerminal !== false) {
-      await transport
-        .signalParentTerminal({
-          status: aborted ? 'cancelled' : 'failed',
-          error: message,
-        })
-        .catch(() => null);
+      });
     }
+    await signalParentPlayTerminal({
+      req,
+      status: aborted ? 'cancelled' : 'failed',
+      error: message,
+    }).catch(() => null);
     throw error;
   }
 }
@@ -4397,39 +4069,36 @@ function extractMaxCreditsPerRun(contractSnapshot: unknown): number | null {
 
 async function finalizeWorkerComputeBilling(input: {
   req: RunRequest;
-  transport?: WorkerRuntimeTransport;
   success: boolean;
   actionEstimate: number;
 }): Promise<void> {
   const maxCreditsPerRun = extractMaxCreditsPerRun(input.req.contractSnapshot);
-  const transport = input.transport ?? createWorkerRuntimeTransport(input.req);
-  await transport.postRuntimeApi(
-    runtimeBillingActions.finalize({
-      sessionId: input.req.runId,
-      orgId: input.req.orgId,
-      operation: 'workflow_run',
-      status: input.success ? 'completed' : 'error',
-      workflowId: input.req.runId,
-      runId: input.req.runId,
-      ...(maxCreditsPerRun !== null ? { maxCreditsPerRun } : {}),
-      finalItem: {
-        itemId: `cloudflare-workflows:${input.req.runId}`,
-        source: 'cloudflare_workflows',
-        unit: 'action',
-        units: Math.max(1, Math.ceil(input.actionEstimate)),
-        providerCostUsd: Number(
-          (
-            Math.max(1, Math.ceil(input.actionEstimate)) *
-            (50 / 1_000_000)
-          ).toFixed(12),
-        ),
-        metadata: {
-          workflowId: input.req.runId,
-          actionEstimate: input.actionEstimate,
-        },
+  await postRuntimeApi(input.req.baseUrl, input.req.executorToken, {
+    action: 'compute_billing_finalize',
+    sessionId: input.req.runId,
+    orgId: input.req.orgId,
+    operation: 'workflow_run',
+    status: input.success ? 'completed' : 'error',
+    workflowId: input.req.runId,
+    runId: input.req.runId,
+    ...(maxCreditsPerRun !== null ? { maxCreditsPerRun } : {}),
+    finalItem: {
+      itemId: `cloudflare-workflows:${input.req.runId}`,
+      source: 'cloudflare_workflows',
+      unit: 'action',
+      units: Math.max(1, Math.ceil(input.actionEstimate)),
+      providerCostUsd: Number(
+        (
+          Math.max(1, Math.ceil(input.actionEstimate)) *
+          (50 / 1_000_000)
+        ).toFixed(12),
+      ),
+      metadata: {
+        workflowId: input.req.runId,
+        actionEstimate: input.actionEstimate,
       },
-    }),
-  );
+    },
+  });
 }
 
 function isInlineCsv(
@@ -4593,7 +4262,7 @@ function trimResultShape(value: unknown): unknown {
   const out: Record<string, unknown> = {};
   for (const [key, child] of Object.entries(value)) {
     if (key === 'preview' && Array.isArray(child) && value.kind === 'dataset') {
-      out[key] = child.slice(0, 10).map(trimResultShape);
+      out[key] = child.slice(0, 5).map(trimResultShape);
     } else {
       out[key] = trimResultShape(child);
     }
@@ -4631,20 +4300,34 @@ function serializeValue(value: unknown, depth: number): unknown {
         ? (value as unknown as { __deeplineCacheSummary: string })
             .__deeplineCacheSummary
         : null;
-    const rows = value
+    const workProgress =
+      isRecord(
+        (value as unknown as { __deeplineWorkProgress?: unknown })
+          .__deeplineWorkProgress,
+      )
+        ? (value as unknown as { __deeplineWorkProgress: Record<string, unknown> })
+            .__deeplineWorkProgress
+        : null;
+    const previewRows = value
+      .slice(0, 5)
       .map((row) => serializeValue(row, depth + 1))
       .filter(isRecord);
     if (tableNamespace && datasetId) {
-      const columns = inferColumns(rows);
+      const columns = inferColumns(
+        value.map((row) => serializeValue(row, depth + 1)).filter(isRecord),
+      );
       return {
         kind: 'dataset' as const,
         datasetKind,
         datasetId,
         count: datasetCount,
         columns,
-        preview: rows,
+        preview: previewRows,
         tableNamespace,
         ...(cacheSummary ? { cacheSummary } : {}),
+        ...(workProgress
+          ? { _metadata: { workProgress } }
+          : {}),
       };
     }
     return value.map((entry) => serializeValue(entry, depth + 1));
@@ -4729,18 +4412,16 @@ export class TenantWorkflow extends WorkflowEntrypoint<
   ): Promise<unknown> {
     const req = runRequestFromWorkflowParams(event.payload);
     const runPrefix = `[deepline-run:${req.runId}]`;
-    recordDynamicWorkerPerfTrace({
-      env: this.env,
-      runId: req.runId,
-      phase: 'dynamic_worker.tenant_workflow_run_start',
-      ms: 0,
-      graphHash: req.graphHash ?? null,
-      waitUntil:
-        typeof this.ctx.waitUntil === 'function'
-          ? (promise) => this.ctx.waitUntil(promise)
-          : undefined,
-    });
+    // DEBUG: confirm TenantWorkflow.run was invoked at all. If this log
+    // appears in tail (parent's tail consumer captures harness logs by
+    // the deepline-run prefix in flushTailRunLogs), the throw is
+    // somewhere inside executeRunRequest. If it doesn't appear, the
+    // throw is in the framework wrapper between the loader and run().
+    console.log(
+      `${runPrefix} TenantWorkflow.run entered baseUrl=${req.baseUrl}`,
+    );
     captureCoordinatorBinding(this.env);
+    captureRuntimeApiBinding(this.env);
     // Hand the harness service binding (if wired) to the SDK-side stub.
     // Must run BEFORE any SDK call site that would reach into HARNESS,
     // i.e. before user play code is invoked. Idempotent within a run.
@@ -4749,23 +4430,10 @@ export class TenantWorkflow extends WorkflowEntrypoint<
     // same isolate). Awaited so the result is in the log before user code
     // begins, but never throws — broken HARNESS at probe time doesn't
     // block the play; real call-site errors do.
-    const harnessProbeStartedAt = nowMs();
     await probeHarnessOnce(this.env, runPrefix);
-    recordDynamicWorkerPerfTrace({
-      env: this.env,
-      runId: req.runId,
-      phase: 'dynamic_worker.harness_probe',
-      ms: nowMs() - harnessProbeStartedAt,
-      graphHash: req.graphHash ?? null,
-      waitUntil:
-        typeof this.ctx.waitUntil === 'function'
-          ? (promise) => this.ctx.waitUntil(promise)
-          : undefined,
-    });
     const abortController = new AbortController();
-    const executeStartedAt = nowMs();
     try {
-      const output = (await executeRunRequest(
+      return (await executeRunRequest(
         req,
         this.env,
         (runnerEvent) => {
@@ -4778,47 +4446,9 @@ export class TenantWorkflow extends WorkflowEntrypoint<
           }
         },
         step,
-        {
-          persistResultDatasets: !req.playCallGovernance,
-          abortController,
-          waitUntil:
-            typeof this.ctx.waitUntil === 'function'
-              ? (promise) => this.ctx.waitUntil(promise)
-              : undefined,
-        },
+        { persistResultDatasets: !req.playCallGovernance, abortController },
       )) as Record<string, unknown>;
-      recordDynamicWorkerPerfTrace({
-        env: this.env,
-        runId: req.runId,
-        phase: 'dynamic_worker.execute_run_request',
-        ms: nowMs() - executeStartedAt,
-        graphHash: req.graphHash ?? null,
-        extra: { ok: true },
-        waitUntil:
-          typeof this.ctx.waitUntil === 'function'
-            ? (promise) => this.ctx.waitUntil(promise)
-            : undefined,
-      });
-      return output;
     } catch (error) {
-      recordDynamicWorkerPerfTrace({
-        env: this.env,
-        runId: req.runId,
-        phase: 'dynamic_worker.execute_run_request',
-        ms: nowMs() - executeStartedAt,
-        graphHash: req.graphHash ?? null,
-        extra: {
-          ok: false,
-          error:
-            error instanceof Error
-              ? error.message.slice(0, 300)
-              : String(error),
-        },
-        waitUntil:
-          typeof this.ctx.waitUntil === 'function'
-            ? (promise) => this.ctx.waitUntil(promise)
-            : undefined,
-      });
       // CF Workflows + the dynamic-workflows framework swallow the error
       // message and surface only "internal error; reference = <id>" via
       // instance.status(). The per-play Worker's console.error doesn't
@@ -4840,13 +4470,12 @@ export class TenantWorkflow extends WorkflowEntrypoint<
       // so this callback is the ONLY way the real error message reaches the
       // user via tail/SSE. Retry with backoff before giving up; if we drop
       // it, the user is stuck staring at the opaque CF reference id.
-      const errorPayload = JSON.stringify(
-        runtimeRunActions.updateStatus({
-          playId: req.runId,
-          status: 'failed',
-          error: `TenantWorkflow.run threw: ${detail.name ?? 'Error'}: ${detail.message}\n${detail.stack ?? ''}`,
-        }),
-      );
+      const errorPayload = JSON.stringify({
+        action: 'update_run_status',
+        playId: req.runId,
+        status: 'failed',
+        error: `TenantWorkflow.run threw: ${detail.name ?? 'Error'}: ${detail.message}\n${detail.stack ?? ''}`,
+      });
       const backoffMs = [200, 500, 1500];
       let lastCallbackError: unknown = null;
       let delivered = false;
@@ -4903,80 +4532,17 @@ export class TenantWorkflow extends WorkflowEntrypoint<
   }
 }
 
-async function handleInlineRun(
-  request: Request,
-  env: WorkerEnv,
-): Promise<Response> {
-  const parseStartedAt = nowMs();
-  const req = (await request.json()) as RunRequest;
-  const runPrefix = `[deepline-run:${req.runId}]`;
-  const events: RunnerEvent[] = [];
-  captureCoordinatorBinding(env);
-  captureHarnessBinding(env);
-  await probeHarnessOnce(env, runPrefix);
-  try {
-    const output = await executeRunRequest(
-      req,
-      env,
-      (runnerEvent) => {
-        events.push(runnerEvent);
-        if (runnerEvent.type === 'log') {
-          console.log(`${runPrefix} ${runnerEvent.message}`);
-        } else if (runnerEvent.type === 'error') {
-          console.error(
-            `${runPrefix} ${runnerEvent.message}${runnerEvent.stack ? `\n${runnerEvent.stack}` : ''}`,
-          );
-        }
-      },
-      undefined,
-      {
-        persistResultDatasets: false,
-        signalParentTerminal: false,
-      },
-    );
-    return Response.json({
-      status: 'completed',
-      result: output.result,
-      outputRows: output.outputRows,
-      durationMs: output.durationMs,
-      parseMs: nowMs() - parseStartedAt,
-      events,
-    });
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    const stack = error instanceof Error ? error.stack : undefined;
-    events.push({
-      type: 'error',
-      message,
-      ...(stack ? { stack } : {}),
-      ts: nowMs(),
-    });
-    return Response.json(
-      {
-        status: 'failed',
-        error: { message, ...(stack ? { stack } : {}) },
-        parseMs: nowMs() - parseStartedAt,
-        events,
-      },
-      { status: 200 },
-    );
-  }
-}
-
 const workerEntrypoint = {
   async fetch(request: Request, env: WorkerEnv): Promise<Response> {
     const url = new URL(request.url);
     if (request.method === 'POST' && url.pathname === '/start') {
-      const startTotalStartedAt = Date.now();
       if (!env.WORKFLOWS) {
         return new Response('missing WORKFLOWS binding', { status: 500 });
       }
-      const parseStartedAt = Date.now();
       const body = (await request.json().catch(() => null)) as {
         id?: string;
         payload?: Record<string, unknown>;
       } | null;
-      const parseMs = Date.now() - parseStartedAt;
       if (!body?.id || !isRecord(body.payload)) {
         return new Response('invalid workflow start body', { status: 400 });
       }
@@ -4992,16 +4558,6 @@ const workerEntrypoint = {
         typeof body.payload.graphHash === 'string'
           ? body.payload.graphHash
           : null;
-      console.log(
-        `[perf-trace] ${JSON.stringify({
-          ts: Date.now(),
-          source: 'dynamic_worker',
-          runId,
-          phase: 'dynamic_worker.start_request_parse',
-          ms: parseMs,
-          ...(graphHash ? { graphHash } : {}),
-        })}`,
-      );
       console.log(
         `[perf-trace] ${JSON.stringify({
           ts: Date.now(),
@@ -5016,18 +4572,13 @@ const workerEntrypoint = {
         id: instance.id,
         status: 'submitted',
         timingsMs: {
-          startRequestParse: parseMs,
           workflowCreate: workflowCreateMs,
-          startTotal: Date.now() - startTotalStartedAt,
         },
       });
     }
     if (request.method === 'POST' && url.pathname === '/run') {
       return handleRun(request, env);
     }
-    if (request.method === 'POST' && url.pathname === '/run-inline') {
-      return handleInlineRun(request, env);
-    }
     if (request.method === 'GET' && url.pathname === '/health') {
       return new Response('ok', { status: 200 });
     }