deepline 0.1.78 → 0.1.80

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

@@ -53,6 +53,14 @@ import {
   decideWorkflowPlatformRetry,
   PLATFORM_DEPLOY_WORKFLOW_RETRY_LIMIT,
 } from './workflow-retry';
+import {
+  WORKFLOW_RETRY_PARAMS_EXTERNALIZE_AFTER_BYTES,
+  WORKFLOW_RETRY_PARAMS_MAX_BYTES,
+  buildWorkflowRetryParams,
+  jsonByteLength,
+  workflowRetryParamsStorageKey,
+  type WorkflowRetryParamsRef,
+} from './workflow-retry-state';
 import { sanitizeLiveLogLines } from './runtime/live-progress';
 
 export { DynamicWorkflowBinding };
@@ -104,6 +112,7 @@ export type PlayWorkflowParams = {
   totalRows?: number;
   coordinatorUrl?: string | null;
   coordinatorInternalToken?: string | null;
+  submittedAt?: number | null;
 };
 
 type InlineChildSubmitResult =
@@ -167,6 +176,12 @@ type CoordinatorTerminalState = {
   completedAt?: number;
 };
 
+type CoordinatorChildTerminalState = {
+  eventKey: string;
+  data: unknown;
+  storedAt: number;
+};
+
 type CoordinatorRunEvent =
   | {
       seq?: number;
@@ -216,6 +231,11 @@ type InlineWorkerRunResponse = {
   outputRows?: number;
   durationMs?: number;
   parseMs?: number;
+  timings?: Array<{
+    phase?: unknown;
+    ms?: unknown;
+    extra?: unknown;
+  }>;
   events?: Array<
     | { type: 'log'; message?: string; level?: string; ts?: number }
     | { type: 'result'; result?: unknown; outputRows?: number; ts?: number }
@@ -230,7 +250,7 @@ function isRecord(value: unknown): value is Record<string, unknown> {
 }
 
 interface CoordinatorEnv {
-  PLAY_WORKFLOW: Workflow<PlayWorkflowParams | PooledWorkflowBootstrapPayload>;
+  PLAY_WORKFLOW: Workflow<PlayWorkflowParams>;
   PLAY_DEDUP: DurableObjectNamespace;
   LOADER?: {
     get(
@@ -523,6 +543,67 @@ async function readCoordinatorTerminalState(
   return state as CoordinatorTerminalState;
 }
 
+async function writeCoordinatorChildTerminalState(input: {
+  env: CoordinatorEnv;
+  parentRunId: string;
+  eventKey: string;
+  data: unknown;
+}): Promise<void> {
+  const stub = input.env.PLAY_DEDUP.get(
+    input.env.PLAY_DEDUP.idFromName(input.parentRunId),
+  );
+  const response = await stub.fetch(
+    'https://deepline.dedup.internal/child-terminal-set',
+    {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({
+        eventKey: input.eventKey,
+        data: input.data,
+        storedAt: Date.now(),
+      }),
+    },
+  );
+  if (!response.ok) {
+    throw new Error(`coordinator child terminal set failed ${response.status}`);
+  }
+}
+
+async function readCoordinatorChildTerminalState(input: {
+  env: CoordinatorEnv;
+  parentRunId: string;
+  eventKey: string;
+  timeoutMs?: number;
+}): Promise<CoordinatorChildTerminalState | null> {
+  const stub = input.env.PLAY_DEDUP.get(
+    input.env.PLAY_DEDUP.idFromName(input.parentRunId),
+  );
+  const endpoint =
+    input.timeoutMs && input.timeoutMs > 0
+      ? 'child-terminal-await'
+      : 'child-terminal-get';
+  const timeoutParam =
+    input.timeoutMs && input.timeoutMs > 0
+      ? `&timeoutMs=${encodeURIComponent(String(Math.floor(input.timeoutMs)))}`
+      : '';
+  const response = await stub.fetch(
+    `https://deepline.dedup.internal/${endpoint}?eventKey=${encodeURIComponent(
+      input.eventKey,
+    )}${timeoutParam}`,
+  );
+  if (!response.ok) {
+    throw new Error(
+      `coordinator child terminal ${endpoint} failed ${response.status}`,
+    );
+  }
+  const body = (await response.json().catch(() => ({}))) as {
+    state?: unknown;
+  };
+  const state = body.state;
+  if (!isRecord(state) || state.eventKey !== input.eventKey) return null;
+  return state as CoordinatorChildTerminalState;
+}
+
 function workflowEventType(name: string): string {
   const normalized = name
     .trim()
@@ -547,36 +628,9 @@ type DynamicWorkflowMetadata = {
   }> | null;
 };
 
-type DispatcherEnvelope = {
-  __dispatcherMetadata: DynamicWorkflowMetadata;
-  params: PlayWorkflowParams;
-};
-
-type PooledWorkflowBootstrapPayload = {
-  __deeplinePooledWorkflow: true;
-  poolId: string;
-  createdAt: number;
-};
-
-const WORKFLOW_POOL_PROTOCOL_VERSION =
-  'pooled-workflow-wait-v14-ready-signal-http-storage';
-const WORKFLOW_POOL_DO_NAME = 'workflow-pool:v2';
-const WORKFLOW_POOL_START_EVENT_TYPE = 'play_start';
-const WORKFLOW_POOL_TTL_MS = 8 * 60 * 1000;
-const WORKFLOW_POOL_TARGET_SIZE = 0;
-const WORKFLOW_POOL_READY_TIMEOUT_MS = 1_500;
-const WORKFLOW_POOL_READY_POLL_MS = 250;
-const WORKFLOW_POOL_REFILL_ON_MISS_TIMEOUT_MS = 2_500;
-const WORKFLOW_POOL_REFILL_ON_MISS_MIN_AVAILABLE = 4;
-const WORKFLOW_POOL_CONTROL_TIMEOUT_MS = 750;
-const WORKFLOW_POOL_START_ACK_TIMEOUT_MS = 750;
-const WORKFLOW_POOL_START_ACK_POLL_MS = 25;
 const SUBMIT_INITIAL_STATE_MAX_WAIT_MS = 0;
 const SUBMIT_INITIAL_STATE_POLL_MS = 50;
 const WORKFLOW_RETRY_STATE_TTL_MS = 60 * 60 * 1000;
-const WORKFLOW_POOL_PREWARM_ESCALATE_TARGET_AFTER_MS = 250;
-const WORKFLOW_POOL_SCHEDULED_REFILL_MIN_AVAILABLE = 1;
-const WORKFLOW_POOL_SCHEDULED_REFILL_TIMEOUT_MS = 10_000;
 
 function buildDynamicWorkflowMetadata(
   params: PlayWorkflowParams,
@@ -591,35 +645,11 @@ function buildDynamicWorkflowMetadata(
   };
 }
 
-function buildDispatcherEnvelope(
-  params: PlayWorkflowParams,
-): DispatcherEnvelope {
-  // Mirrors @cloudflare/dynamic-workflows' envelope. We need to send the
-  // dispatcher payload via Workflow sendEvent for prewarmed instances; the
-  // public wrapper only applies this envelope to create() params.
-  return {
-    __dispatcherMetadata: buildDynamicWorkflowMetadata(params),
-    params,
-  };
-}
-
-function isPooledWorkflowBootstrapPayload(
-  value: unknown,
-): value is PooledWorkflowBootstrapPayload {
-  return (
-    Boolean(value) &&
-    typeof value === 'object' &&
-    !Array.isArray(value) &&
-    (value as Record<string, unknown>).__deeplinePooledWorkflow === true &&
-    typeof (value as Record<string, unknown>).poolId === 'string'
-  );
-}
-
 function readWorkflowTraceContext(event: unknown): {
   runId: string;
   graphHash: string | null;
   instanceId: string | null;
-  pooledBootstrap: boolean;
+  submittedAt: number | null;
 } {
   const record = isRecord(event) ? event : {};
   const payload = isRecord(record.payload) ? record.payload : {};
@@ -627,17 +657,15 @@ function readWorkflowTraceContext(event: unknown): {
   const metadata = isRecord(payload.__dispatcherMetadata)
     ? payload.__dispatcherMetadata
     : null;
-  const pooled = isPooledWorkflowBootstrapPayload(payload);
   const runId =
     (typeof params?.runId === 'string' && params.runId) ||
     (typeof metadata?.runId === 'string' && metadata.runId) ||
-    (pooled && typeof payload.poolId === 'string' ? payload.poolId : null) ||
     (typeof record.instanceId === 'string' && record.instanceId) ||
     'unknown-workflow-run';
   const graphHash =
     (typeof params?.graphHash === 'string' && params.graphHash) ||
     (typeof metadata?.graphHash === 'string' && metadata.graphHash) ||
-    (pooled ? 'workflow-pool' : null);
+    null;
   return {
     runId,
     graphHash,
@@ -645,18 +673,14 @@ function readWorkflowTraceContext(event: unknown): {
       typeof record.instanceId === 'string' && record.instanceId
         ? record.instanceId
         : null,
-    pooledBootstrap: pooled,
+    submittedAt:
+      typeof params?.submittedAt === 'number' &&
+      Number.isFinite(params.submittedAt)
+        ? params.submittedAt
+        : null,
   };
 }
 
-function workflowPoolEnabled(): boolean {
-  return WORKFLOW_POOL_TARGET_SIZE > 0;
-}
-
-function workflowPoolTargetSize(): number {
-  return WORKFLOW_POOL_TARGET_SIZE;
-}
-
 async function waitForSubmitInitialState(input: {
   instance: WorkflowInstance;
   runId: string;
@@ -704,87 +728,110 @@ async function createDynamicWorkflowInstance(input: {
   });
 }
 
+function runScopedDurableObject(
+  env: CoordinatorEnv,
+  runId: string,
+): DurableObjectStub {
+  return env.PLAY_DEDUP.get(env.PLAY_DEDUP.idFromName(runId));
+}
+
 /**
- * Returns the slug-rooted Durable Scope key for the workflow pool DO.
- *
- * The pool DO name is a *shared* (non-runId) key, so without slug-scoping
- * a single Cloudflare account running multiple PR previews would collide
- * on `workflow-pool:v2`. The slug isolates the pool per-preview.
- *
- * See docs/adr/0005-durable-scope.md.
+ * Address the rate-state Durable Object for a single `<orgId>:<provider>`
+ * bucket. Keying the DO by the bucket id (not the run id) makes one
+ * single-threaded instance own that bucket's request window across every
+ * isolate of every run in the org — which is exactly what the distributed Rate
+ * State Backend needs. Reuses the PlayDedup namespace (the DO already hosts the
+ * token-bucket handlers) so no extra binding is required.
  */
-function workflowPoolDurableObjectName(env: CoordinatorEnv): string {
-  const slug = env.DEEPLINE_PLAY_PREVIEW_SLUG?.trim();
-  return slug ? `${slug}:${WORKFLOW_POOL_DO_NAME}` : WORKFLOW_POOL_DO_NAME;
+function rateBucketDurableObject(
+  env: CoordinatorEnv,
+  bucketId: string,
+): DurableObjectStub {
+  return env.PLAY_DEDUP.get(env.PLAY_DEDUP.idFromName(`rate:${bucketId}`));
 }
 
-function workflowPoolDurableObject(env: CoordinatorEnv): DurableObjectStub {
-  return env.PLAY_DEDUP.get(
-    env.PLAY_DEDUP.idFromName(workflowPoolDurableObjectName(env)),
+async function callRateBucketControl<T>(
+  env: CoordinatorEnv,
+  bucketId: string,
+  path: string,
+  body: unknown,
+): Promise<T> {
+  const response = await rateBucketDurableObject(env, bucketId).fetch(
+    `https://deepline.rate-state.internal${path}`,
+    {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify(body),
+    },
   );
+  if (!response.ok) {
+    throw new Error(
+      `rate state ${path} failed ${response.status}: ${(
+        await response.text().catch(() => '')
+      ).slice(0, 400)}`,
+    );
+  }
+  return (await response.json()) as T;
 }
 
-function runScopedDurableObject(
+async function callRunScopedControl<T>(
   env: CoordinatorEnv,
   runId: string,
-): DurableObjectStub {
-  return env.PLAY_DEDUP.get(env.PLAY_DEDUP.idFromName(runId));
-}
-
-async function callWorkflowPool<T>(
-  env: CoordinatorEnv,
   path: string,
-  init?: RequestInit & { timeoutMs?: number },
+  init?: RequestInit,
 ): Promise<T> {
-  const timeoutMs = Math.max(
-    1,
-    Math.floor(init?.timeoutMs ?? WORKFLOW_POOL_CONTROL_TIMEOUT_MS),
+  const response = await runScopedDurableObject(env, runId).fetch(
+    `https://deepline.run-state.internal${path}`,
+    {
+      ...(init ?? {}),
+      headers: {
+        'content-type': 'application/json',
+        ...(init?.headers ?? {}),
+      },
+    },
   );
-  let timeoutId: ReturnType<typeof setTimeout> | null = null;
-  try {
-    const fetchInit: RequestInit = { ...(init ?? {}) };
-    delete (fetchInit as { timeoutMs?: number }).timeoutMs;
-    delete fetchInit.signal;
-    const response = await Promise.race([
-      workflowPoolDurableObject(env).fetch(
-        `https://deepline.workflow-pool.internal${path}`,
-        {
-          ...fetchInit,
-          headers: {
-            'content-type': 'application/json',
-            ...(init?.headers ?? {}),
-          },
-        },
-      ),
-      new Promise<Response>((_, reject) => {
-        timeoutId = setTimeout(
-          () =>
-            reject(
-              new Error(`workflow pool ${path} timed out after ${timeoutMs}ms`),
-            ),
-          timeoutMs,
-        );
-      }),
-    ]);
-    if (!response.ok) {
-      throw new Error(
-        `workflow pool ${path} failed ${response.status}: ${(
-          await response.text().catch(() => '')
-        ).slice(0, 400)}`,
-      );
-    }
-    return (await response.json()) as T;
-  } catch (error) {
-    if (
-      error instanceof Error &&
-      (error.name === 'AbortError' || error.message.includes('aborted'))
-    ) {
-      throw new Error(`workflow pool ${path} timed out after ${timeoutMs}ms`);
-    }
-    throw error;
-  } finally {
-    if (timeoutId) clearTimeout(timeoutId);
+  if (!response.ok) {
+    throw new Error(
+      `run state ${path} failed ${response.status}: ${(
+        await response.text().catch(() => '')
+      ).slice(0, 400)}`,
+    );
   }
+  return (await response.json()) as T;
+}
+
+async function recordWorkflowInstanceId(input: {
+  env: CoordinatorEnv;
+  runId: string;
+  instanceId: string;
+}): Promise<void> {
+  await callRunScopedControl<{ ok?: unknown }>(
+    input.env,
+    input.runId,
+    '/workflow-instance-put',
+    {
+      method: 'POST',
+      body: JSON.stringify({
+        runId: input.runId,
+        instanceId: input.instanceId,
+        ttlMs: WORKFLOW_RETRY_STATE_TTL_MS,
+      }),
+    },
+  );
+}
+
+async function resolveWorkflowInstanceIdForRun(
+  env: CoordinatorEnv,
+  runId: string,
+): Promise<string> {
+  const body = await callRunScopedControl<{ instanceId?: unknown }>(
+    env,
+    runId,
+    `/workflow-instance-get?runId=${encodeURIComponent(runId)}`,
+  ).catch(() => ({ instanceId: null }));
+  return typeof body.instanceId === 'string' && body.instanceId
+    ? body.instanceId
+    : workflowInstanceId(runId);
 }
 
 function assertEncryptedPreloadedDbSessions(
@@ -804,49 +851,6 @@ function assertEncryptedPreloadedDbSessions(
   }
 }
 
-async function persistWorkflowDbSessions(input: {
-  env: CoordinatorEnv;
-  runId: string;
-  sessions: PreloadedRuntimeDbSession[];
-}): Promise<NonNullable<PlayWorkflowParams['preloadedDbSessionRef']>> {
-  assertEncryptedPreloadedDbSessions(input.sessions);
-  const response = await runScopedDurableObject(input.env, input.runId).fetch(
-    'https://deepline.dedup.internal/db-sessions-put',
-    {
-      method: 'POST',
-      headers: { 'content-type': 'application/json' },
-      body: JSON.stringify({
-        runId: input.runId,
-        sessions: input.sessions,
-        ttlMs: DB_SESSION_DEFAULT_TTL_SECONDS * 1000,
-      }),
-    },
-  );
-  if (!response.ok) {
-    throw new Error(
-      `workflow db session storage failed ${response.status}: ${(
-        await response.text().catch(() => '')
-      ).slice(0, 400)}`,
-    );
-  }
-  const body = (await response.json().catch(() => ({}))) as {
-    sessionCount?: unknown;
-    expiresAt?: unknown;
-  };
-  return {
-    runId: input.runId,
-    sessionCount:
-      typeof body.sessionCount === 'number' &&
-      Number.isFinite(body.sessionCount)
-        ? body.sessionCount
-        : input.sessions.length,
-    expiresAt:
-      typeof body.expiresAt === 'number' && Number.isFinite(body.expiresAt)
-        ? body.expiresAt
-        : Date.now() + DB_SESSION_DEFAULT_TTL_SECONDS * 1000,
-  };
-}
-
 async function readWorkflowDbSessions(input: {
   env: CoordinatorEnv;
   ref: NonNullable<PlayWorkflowParams['preloadedDbSessionRef']>;
@@ -877,34 +881,56 @@ async function readWorkflowDbSessions(input: {
   return sessions;
 }
 
-async function externalizeWorkflowDbSessions(input: {
+async function readWorkflowDbSessionsWithRetry(input: {
   env: CoordinatorEnv;
+  ref: NonNullable<PlayWorkflowParams['preloadedDbSessionRef']>;
+}): Promise<PreloadedRuntimeDbSession[]> {
+  const delays = [25, 50, 100, 200] as const;
+  let lastError: unknown = null;
+  for (let attempt = 0; attempt <= delays.length; attempt += 1) {
+    try {
+      return await readWorkflowDbSessions(input);
+    } catch (error) {
+      lastError = error;
+      const message = error instanceof Error ? error.message : String(error);
+      if (
+        !message.includes('workflow db session lookup failed 404') ||
+        attempt >= delays.length
+      ) {
+        throw error;
+      }
+      await sleep(delays[attempt]);
+    }
+  }
+  throw lastError instanceof Error ? lastError : new Error(String(lastError));
+}
+
+function externalizedWorkflowDbSessionParams(input: {
   params: PlayWorkflowParams;
-  recordSubmitTiming?: (timing: CoordinatorTiming) => void;
-}): Promise<PlayWorkflowParams> {
+}): {
+  params: PlayWorkflowParams;
+  sessions: PreloadedRuntimeDbSession[];
+  ref: NonNullable<PlayWorkflowParams['preloadedDbSessionRef']> | null;
+} {
   const sessions = Array.isArray(input.params.preloadedDbSessions)
     ? input.params.preloadedDbSessions
     : [];
-  if (sessions.length === 0) return input.params;
-  const startedAt = Date.now();
-  const ref = await persistWorkflowDbSessions({
-    env: input.env,
+  if (sessions.length === 0) {
+    return { params: input.params, sessions, ref: null };
+  }
+  const ref: NonNullable<PlayWorkflowParams['preloadedDbSessionRef']> = {
     runId: input.params.runId,
-    sessions,
-  });
-  input.recordSubmitTiming?.({
-    phase: 'coordinator.workflow_db_sessions_externalized',
-    ms: Date.now() - startedAt,
-    graphHash: input.params.graphHash ?? null,
-    extra: {
-      sessions: sessions.length,
-      expiresAt: ref.expiresAt,
-    },
-  });
+    sessionCount: sessions.length,
+    expiresAt: Date.now() + DB_SESSION_DEFAULT_TTL_SECONDS * 1000,
+  };
   return {
-    ...input.params,
-    preloadedDbSessions: null,
-    preloadedDbSessionRef: ref,
+    params: {
+      ...input.params,
+      preloadedDbSessions: null,
+      preloadedDbSessionRef: ref,
+    },
+    sessions,
+    ref,
   };
 }
 
@@ -941,7 +967,10 @@ async function hydrateWorkflowDbSessions(input: {
   const ref = readPreloadedDbSessionRef(params.preloadedDbSessionRef);
   if (!ref) return input.event;
   const startedAt = Date.now();
-  const sessions = await readWorkflowDbSessions({ env: input.env, ref });
+  const sessions = await readWorkflowDbSessionsWithRetry({
+    env: input.env,
+    ref,
+  });
   input.trace({
     runId: ref.runId,
     phase: 'coordinator.workflow_db_sessions_hydrated',
@@ -969,278 +998,312 @@ async function hydrateWorkflowDbSessions(input: {
   };
 }
 
-type WorkflowPoolCounts = {
-  available: number;
-  warming: number;
-};
-
-type WorkflowPoolRefillResult = WorkflowPoolCounts & {
-  target: number;
-  created: number;
-  promoted: number;
-  removed: number;
-  waitedMs: number;
-  waitIterations: number;
-};
-
-type WorkflowPoolListEntry = {
-  id: string;
-  state: string;
-  createdAt: number;
-  readyAt: number | null;
-  expiresAt: number;
-};
-
-async function workflowPoolCount(
-  env: CoordinatorEnv,
-): Promise<WorkflowPoolCounts> {
-  const body = await callWorkflowPool<{
-    available?: unknown;
-    warming?: unknown;
-  }>(
-    env,
-    `/pool-count?version=${encodeURIComponent(WORKFLOW_POOL_PROTOCOL_VERSION)}`,
-  );
-  return {
-    available: typeof body.available === 'number' ? body.available : 0,
-    warming: typeof body.warming === 'number' ? body.warming : 0,
-  };
-}
-
 function sleep(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
-async function listWorkflowPoolEntries(
-  env: CoordinatorEnv,
-): Promise<WorkflowPoolListEntry[]> {
-  const body = await callWorkflowPool<{ entries?: unknown }>(
-    env,
-    `/pool-list?version=${encodeURIComponent(WORKFLOW_POOL_PROTOCOL_VERSION)}`,
-  );
-  if (!Array.isArray(body.entries)) return [];
-  return body.entries
-    .filter((entry): entry is Record<string, unknown> =>
-      Boolean(entry && typeof entry === 'object' && !Array.isArray(entry)),
-    )
-    .map((entry) => ({
-      id: typeof entry.id === 'string' ? entry.id : '',
-      state: typeof entry.state === 'string' ? entry.state : '',
-      createdAt:
-        typeof entry.createdAt === 'number' && Number.isFinite(entry.createdAt)
-          ? entry.createdAt
-          : 0,
-      readyAt:
-        typeof entry.readyAt === 'number' && Number.isFinite(entry.readyAt)
-          ? entry.readyAt
-          : null,
-      expiresAt:
-        typeof entry.expiresAt === 'number' && Number.isFinite(entry.expiresAt)
-          ? entry.expiresAt
-          : 0,
-    }))
-    .filter((entry) => entry.id);
+function readWorkflowPayload(event: unknown): Record<string, unknown> | null {
+  if (!isRecord(event)) return null;
+  const payload = event.payload;
+  if (!isRecord(payload)) return null;
+  return isRecord(payload.params) ? payload.params : payload;
 }
 
-async function addWorkflowPoolIds(
-  env: CoordinatorEnv,
-  ids: string[],
-  options?: { ready?: boolean },
-): Promise<void> {
-  if (ids.length === 0) return;
-  await callWorkflowPool(env, '/pool-add', {
-    method: 'POST',
-    body: JSON.stringify({
-      ids,
-      ttlMs: WORKFLOW_POOL_TTL_MS,
-      version: WORKFLOW_POOL_PROTOCOL_VERSION,
-      ready: options?.ready === true,
-      ...(options?.ready === true ? { readyAt: Date.now() } : {}),
-    }),
+async function markWorkflowRuntimeFailure(input: {
+  env: CoordinatorEnv;
+  event: unknown;
+  error: unknown;
+}): Promise<void> {
+  const payload = readWorkflowPayload(input.event);
+  if (!payload) return;
+  const runId = typeof payload.runId === 'string' ? payload.runId : null;
+  const baseUrl = typeof payload.baseUrl === 'string' ? payload.baseUrl : null;
+  const executorToken =
+    typeof payload.executorToken === 'string' ? payload.executorToken : null;
+  if (!runId || !baseUrl || !executorToken) return;
+  const errorName =
+    input.error instanceof Error && input.error.name
+      ? input.error.name
+      : 'Error';
+  const errorMessage =
+    input.error instanceof Error ? input.error.message : String(input.error);
+  const errorStack =
+    input.error instanceof Error && typeof input.error.stack === 'string'
+      ? input.error.stack.split('\n').slice(0, 12).join('\n')
+      : null;
+  const headers = new Headers({
+    authorization: `Bearer ${executorToken}`,
+    'content-type': 'application/json',
   });
-}
-
-async function markWorkflowPoolIdReady(
-  env: CoordinatorEnv,
-  poolId: string,
-): Promise<boolean> {
-  const body = await callWorkflowPool<{ ready?: unknown }>(env, '/pool-ready', {
-    method: 'POST',
-    body: JSON.stringify({
-      poolId,
-      version: WORKFLOW_POOL_PROTOCOL_VERSION,
-    }),
+  const bypass = input.env.VERCEL_PROTECTION_BYPASS_TOKEN?.trim();
+  if (bypass) headers.set('x-vercel-protection-bypass', bypass);
+  const body = JSON.stringify({
+    action: 'append_run_events',
+    playId: runId,
+    events: [
+      {
+        type: 'run.failed',
+        runId,
+        source: 'coordinator',
+        occurredAt: Date.now(),
+        error: `DynamicWorkflow runner failed: ${errorName}: ${errorMessage}${
+          errorStack ? `\n${errorStack}` : ''
+        }`,
+      } satisfies PlayRunLedgerEvent,
+    ],
   });
-  return body.ready === true;
-}
-
-async function promoteWorkflowPoolIds(
-  env: CoordinatorEnv,
-  ids: string[],
-): Promise<void> {
-  if (ids.length === 0) return;
-  await callWorkflowPool(env, '/pool-promote', {
-    method: 'POST',
-    body: JSON.stringify({
-      ids,
-      version: WORKFLOW_POOL_PROTOCOL_VERSION,
-    }),
+  const url = `${baseUrl.replace(/\/$/, '')}/api/v2/plays/internal/runtime`;
+  const backoffMs = [200, 500, 1500];
+  let lastError: unknown = null;
+  for (let attempt = 0; attempt <= backoffMs.length; attempt += 1) {
+    try {
+      const response = await fetch(url, { method: 'POST', headers, body });
+      if (response.ok) return;
+      lastError = new Error(
+        `runtime API responded ${response.status}: ${(await response.text().catch(() => '')).slice(0, 400)}`,
+      );
+      if (
+        response.status >= 400 &&
+        response.status < 500 &&
+        response.status !== 408 &&
+        response.status !== 429
+      ) {
+        break;
+      }
+    } catch (error) {
+      lastError = error;
+    }
+    if (attempt < backoffMs.length) {
+      await new Promise((resolve) => setTimeout(resolve, backoffMs[attempt]));
+    }
+  }
+  console.error('[coordinator] failed to mark workflow runtime failure', {
+    runId,
+    message: lastError instanceof Error ? lastError.message : String(lastError),
   });
 }
 
-async function deleteWorkflowPoolIds(
-  env: CoordinatorEnv,
-  ids: string[],
-): Promise<void> {
-  if (ids.length === 0) return;
-  await callWorkflowPool(env, '/pool-delete', {
-    method: 'POST',
-    body: JSON.stringify({
-      ids,
-      version: WORKFLOW_POOL_PROTOCOL_VERSION,
-    }),
-  });
-}
+type StoredPlayArtifactPayload = {
+  artifact?: {
+    bundledCode?: string;
+    artifactKind?: string;
+  };
+};
 
-async function leaseWorkflowPoolId(
-  env: CoordinatorEnv,
-  runId: string,
-): Promise<string | null> {
-  const body = await callWorkflowPool<{ id?: unknown }>(
-    env,
-    `/pool-claim?version=${encodeURIComponent(WORKFLOW_POOL_PROTOCOL_VERSION)}`,
-    {
-      method: 'POST',
-      body: JSON.stringify({ runId }),
-    },
-  );
-  return typeof body.id === 'string' && body.id ? body.id : null;
-}
+const DYNAMIC_WORKER_COMPATIBILITY_DATE = '2026-05-01';
 
-async function mapRunToWorkflowInstance(input: {
+async function persistWorkflowRetryState(input: {
   env: CoordinatorEnv;
   runId: string;
-  instanceId: string;
-  started?: boolean;
-}): Promise<boolean> {
-  const body = await callWorkflowPool<{ mapped?: unknown }>(
+  params: PlayWorkflowParams;
+}): Promise<void> {
+  const retryParams = buildWorkflowRetryParams(input.params);
+  const paramsBytes = jsonByteLength(retryParams);
+  if (paramsBytes > WORKFLOW_RETRY_PARAMS_MAX_BYTES) {
+    throw new Error(
+      `workflow retry params too large: ${paramsBytes} bytes exceeds ${WORKFLOW_RETRY_PARAMS_MAX_BYTES}. Pass large payloads as staged files or ctx.csv inputs instead of inline JSON.`,
+    );
+  }
+  let body: {
+    runId: string;
+    params?: PlayWorkflowParams;
+    paramsRef?: WorkflowRetryParamsRef;
+    paramsBytes: number;
+    ttlMs: number;
+  };
+  if (paramsBytes > WORKFLOW_RETRY_PARAMS_EXTERNALIZE_AFTER_BYTES) {
+    const serialized = JSON.stringify(retryParams);
+    const hash = stableHash(serialized);
+    const storageKey = workflowRetryParamsStorageKey({
+      runId: input.runId,
+      hash,
+    });
+    await input.env.PLAYS_BUCKET.put(storageKey, serialized, {
+      httpMetadata: { contentType: 'application/json' },
+    });
+    body = {
+      runId: input.runId,
+      paramsRef: {
+        storageKind: 'r2',
+        storageKey,
+        bytes: paramsBytes,
+        hash,
+        expiresAt: Date.now() + WORKFLOW_RETRY_STATE_TTL_MS,
+      },
+      paramsBytes,
+      ttlMs: WORKFLOW_RETRY_STATE_TTL_MS,
+    };
+  } else {
+    body = {
+      runId: input.runId,
+      params: retryParams,
+      paramsBytes,
+      ttlMs: WORKFLOW_RETRY_STATE_TTL_MS,
+    };
+  }
+  await callRunScopedControl<{ ok?: unknown }>(
     input.env,
-    '/pool-map-run',
+    input.runId,
+    '/run-retry-state-put',
     {
       method: 'POST',
-      body: JSON.stringify({
-        runId: input.runId,
-        instanceId: input.instanceId,
-        started: input.started === true,
-        version: WORKFLOW_POOL_PROTOCOL_VERSION,
-      }),
+      body: JSON.stringify(body),
     },
   );
-  return body.mapped !== false;
 }
 
-async function blockWorkflowPoolRun(input: {
+async function persistWorkflowLaunchState(input: {
   env: CoordinatorEnv;
   runId: string;
-  instanceId: string;
-}): Promise<{ blocked: boolean; started: boolean }> {
-  const body = await callWorkflowPool<{
-    blocked?: unknown;
-    started?: unknown;
-  }>(input.env, '/pool-block-run', {
-    method: 'POST',
-    body: JSON.stringify({
+  params: PlayWorkflowParams;
+  sessions: PreloadedRuntimeDbSession[];
+}): Promise<{
+  retryExpiresAt?: number;
+  dbSessionsExpiresAt?: number;
+  sessionCount?: number;
+}> {
+  if (input.sessions.length === 0) {
+    await persistWorkflowRetryState({
+      env: input.env,
       runId: input.runId,
-      instanceId: input.instanceId,
-      version: WORKFLOW_POOL_PROTOCOL_VERSION,
-    }),
+      params: input.params,
+    });
+    return {};
+  }
+  const retryParams = buildWorkflowRetryParams(input.params);
+  const paramsBytes = jsonByteLength(retryParams);
+  let body: {
+    runId: string;
+    params?: PlayWorkflowParams;
+    paramsRef?: WorkflowRetryParamsRef;
+    paramsBytes: number;
+    sessions: PreloadedRuntimeDbSession[];
+    retryTtlMs: number;
+    dbSessionsTtlMs: number;
+  };
+  if (paramsBytes > WORKFLOW_RETRY_PARAMS_EXTERNALIZE_AFTER_BYTES) {
+    const serialized = JSON.stringify(retryParams);
+    const hash = stableHash(serialized);
+    const storageKey = workflowRetryParamsStorageKey({
+      runId: input.runId,
+      hash,
+    });
+    await input.env.PLAYS_BUCKET.put(storageKey, serialized, {
+      httpMetadata: { contentType: 'application/json' },
+    });
+    body = {
+      runId: input.runId,
+      paramsRef: {
+        storageKind: 'r2',
+        storageKey,
+        bytes: paramsBytes,
+        hash,
+        expiresAt: Date.now() + WORKFLOW_RETRY_STATE_TTL_MS,
+      },
+      paramsBytes,
+      sessions: input.sessions,
+      retryTtlMs: WORKFLOW_RETRY_STATE_TTL_MS,
+      dbSessionsTtlMs: DB_SESSION_DEFAULT_TTL_SECONDS * 1000,
+    };
+  } else {
+    body = {
+      runId: input.runId,
+      params: retryParams,
+      paramsBytes,
+      sessions: input.sessions,
+      retryTtlMs: WORKFLOW_RETRY_STATE_TTL_MS,
+      dbSessionsTtlMs: DB_SESSION_DEFAULT_TTL_SECONDS * 1000,
+    };
+  }
+  const response = await callRunScopedControl<{
+    ok?: unknown;
+    retryExpiresAt?: unknown;
+    dbSessionsExpiresAt?: unknown;
+    sessionCount?: unknown;
+  }>(input.env, input.runId, '/run-launch-state-put', {
+    method: 'POST',
+    body: JSON.stringify(body),
   });
   return {
-    blocked: body.blocked === true,
-    started: body.started === true,
+    retryExpiresAt:
+      typeof response.retryExpiresAt === 'number'
+        ? response.retryExpiresAt
+        : undefined,
+    dbSessionsExpiresAt:
+      typeof response.dbSessionsExpiresAt === 'number'
+        ? response.dbSessionsExpiresAt
+        : undefined,
+    sessionCount:
+      typeof response.sessionCount === 'number'
+        ? response.sessionCount
+        : undefined,
   };
 }
 
-async function readWorkflowPoolRunMapping(input: {
+async function hydrateWorkflowRetryParams(input: {
   env: CoordinatorEnv;
-  runId: string;
-}): Promise<{ instanceId: string | null; startedAt: number | null }> {
-  const body = await callWorkflowPool<{
-    instanceId?: unknown;
-    startedAt?: unknown;
-  }>(
-    input.env,
-    `/pool-resolve-run?runId=${encodeURIComponent(input.runId)}&version=${encodeURIComponent(
-      WORKFLOW_POOL_PROTOCOL_VERSION,
-    )}`,
-  ).catch(() => ({ instanceId: null, startedAt: null }));
-  return {
-    instanceId:
-      typeof body.instanceId === 'string' && body.instanceId
-        ? body.instanceId
-        : null,
-    startedAt:
-      typeof body.startedAt === 'number' && Number.isFinite(body.startedAt)
-        ? body.startedAt
-        : null,
-  };
+  params: unknown;
+  paramsRef: unknown;
+}): Promise<PlayWorkflowParams | null> {
+  if (isRecord(input.params)) {
+    return input.params as PlayWorkflowParams;
+  }
+  if (!isRecord(input.paramsRef)) {
+    return null;
+  }
+  const storageKind = input.paramsRef.storageKind;
+  const storageKey = input.paramsRef.storageKey;
+  const expectedBytes = input.paramsRef.bytes;
+  const expectedHash = input.paramsRef.hash;
+  if (
+    storageKind !== 'r2' ||
+    typeof storageKey !== 'string' ||
+    !storageKey.startsWith('plays/workflow-retry-params/') ||
+    typeof expectedBytes !== 'number' ||
+    !Number.isFinite(expectedBytes) ||
+    typeof expectedHash !== 'string' ||
+    !expectedHash
+  ) {
+    throw new Error('Invalid workflow retry params reference.');
+  }
+  const object = await input.env.PLAYS_BUCKET.get(storageKey);
+  if (!object) {
+    throw new Error(`Workflow retry params missing from R2: ${storageKey}`);
+  }
+  const text = await object.text();
+  const actualBytes = new TextEncoder().encode(text).length;
+  if (actualBytes !== expectedBytes) {
+    throw new Error(
+      `Workflow retry params byte length mismatch: expected ${expectedBytes}, got ${actualBytes}.`,
+    );
+  }
+  const actualHash = stableHash(text);
+  if (actualHash !== expectedHash) {
+    throw new Error('Workflow retry params hash mismatch.');
+  }
+  const parsed = JSON.parse(text) as unknown;
+  return isRecord(parsed) ? (parsed as PlayWorkflowParams) : null;
 }
 
-async function persistWorkflowRetryState(input: {
-  env: CoordinatorEnv;
+function workflowRetryStatePersistenceErrorResponse(input: {
   runId: string;
-  params: PlayWorkflowParams;
-}): Promise<void> {
-  const retryParams: PlayWorkflowParams = {
-    ...input.params,
-    dynamicWorkerCode: null,
-    contractSnapshot: stripRetrySourceSnapshot(input.params.contractSnapshot),
-    childPlayManifests: stripRetryChildManifestCode(
-      input.params.childPlayManifests,
-    ),
-    packagedFiles:
-      input.params.packagedFiles?.map((file) => ({
-        playPath: file.playPath,
-        storageKey: file.storageKey,
-        contentType: file.contentType,
-        bytes: file.bytes,
-      })) ?? null,
-  };
-  await callWorkflowPool<{ ok?: unknown }>(input.env, '/run-retry-state-put', {
-    method: 'POST',
-    body: JSON.stringify({
-      runId: input.runId,
-      params: retryParams,
-      ttlMs: WORKFLOW_RETRY_STATE_TTL_MS,
-    }),
-  }).catch((error) => {
-    console.warn('[coordinator] workflow retry state persistence skipped', {
-      runId: input.runId,
-      error: error instanceof Error ? error.message : String(error),
-    });
-  });
-}
-
-function stripRetrySourceSnapshot(snapshot: unknown): unknown {
-  if (!isRecord(snapshot)) return snapshot;
-  const rest = { ...snapshot };
-  delete rest.sourceCode;
-  delete rest.sourceFiles;
-  return rest;
-}
-
-function stripRetryChildManifestCode(
-  manifests: PlayRuntimeManifestMap | null | undefined,
-): PlayRuntimeManifestMap | null {
-  if (!manifests) return null;
-  const stripped: PlayRuntimeManifestMap = {};
-  for (const [key, manifest] of Object.entries(manifests)) {
-    const rest = { ...manifest };
-    delete rest.bundledCode;
-    delete rest.sourceCode;
-    stripped[key] = rest;
-  }
-  return stripped;
+  error: unknown;
+}): Response {
+  const message =
+    input.error instanceof Error ? input.error.message : String(input.error);
+  return Response.json(
+    {
+      error: {
+        code: 'WORKFLOW_RETRY_STATE_PERSISTENCE_FAILED',
+        message:
+          'Failed to persist workflow retry state before dispatching the play run.',
+        phase: 'coordinator_retry_state_persistence',
+        runId: input.runId,
+        cause: message,
+      },
+    },
+    { status: 503 },
+  );
 }
 
 async function claimWorkflowPlatformRetry(input: {
@@ -1251,21 +1314,27 @@ async function claimWorkflowPlatformRetry(input: {
   attempts: number;
   params: PlayWorkflowParams | null;
 }> {
-  const body = await callWorkflowPool<{
+  const body = await callRunScopedControl<{
     claimed?: unknown;
     attempts?: unknown;
     params?: unknown;
-  }>(input.env, '/run-retry-claim', {
+    paramsRef?: unknown;
+  }>(input.env, input.runId, '/run-retry-claim', {
     method: 'POST',
     body: JSON.stringify({
       runId: input.runId,
       maxAttempts: PLATFORM_DEPLOY_WORKFLOW_RETRY_LIMIT,
     }),
   });
+  const params = await hydrateWorkflowRetryParams({
+    env: input.env,
+    params: body.params,
+    paramsRef: body.paramsRef,
+  });
   return {
     claimed: body.claimed === true,
     attempts: typeof body.attempts === 'number' ? body.attempts : 0,
-    params: isRecord(body.params) ? (body.params as PlayWorkflowParams) : null,
+    params,
   };
 }
 
@@ -1302,690 +1371,60 @@ async function restartWorkflowAfterPlatformReset(input: {
     console.warn('[coordinator] workflow platform retry claim failed', {
       runId: input.runId,
       error: error instanceof Error ? error.message : String(error),
-    });
-    return null;
-  });
-  if (!claim?.claimed || !claim.params) {
-    return { retried: false, result: null };
-  }
-  const retryInstanceId = workflowRetryInstanceId(input.runId, claim.attempts);
-  const retryStartedAt = Date.now();
-  let retryInstance: WorkflowInstance | null = null;
-  try {
-    retryInstance = await createDynamicWorkflowInstance({
-      env: input.env,
-      id: retryInstanceId,
-      params: claim.params,
-    });
-    await mapRunToWorkflowInstance({
-      env: input.env,
-      runId: input.runId,
-      instanceId: retryInstance.id,
-      started: true,
-    });
-    input.ctx?.waitUntil(input.oldInstance.terminate().catch(() => undefined));
-    recordCoordinatorPerfTraceBuffered(input.env, input.ctx, {
-      runId: input.runId,
-      phase: 'coordinator.platform_deploy_retry',
-      ms: Date.now() - retryStartedAt,
-      graphHash: claim.params.graphHash ?? null,
-      extra: {
-        retryAttempt: claim.attempts,
-        retryInstanceId: retryInstance.id,
-        reason: decision.reason,
-      },
-    });
-    return {
-      retried: true,
-      result: {
-        runId: input.runId,
-        playName: claim.params.playName,
-        status: 'running',
-        result: null,
-        error: null,
-        retry: {
-          reason: decision.reason,
-          attempt: claim.attempts,
-          message: decision.message,
-        },
-      },
-    };
-  } finally {
-    disposeRpcStub(retryInstance);
-  }
-}
-
-async function waitForWorkflowPoolStartAck(input: {
-  env: CoordinatorEnv;
-  runId: string;
-  instanceId: string;
-  timeoutMs: number;
-}): Promise<{
-  acknowledged: boolean;
-  ms: number;
-  polls: number;
-  startedAt: number | null;
-  mappedInstanceId: string | null;
-}> {
-  const startedAt = Date.now();
-  let polls = 0;
-  let latestMapping: { instanceId: string | null; startedAt: number | null } = {
-    instanceId: null,
-    startedAt: null,
-  };
-  while (Date.now() - startedAt < input.timeoutMs) {
-    polls += 1;
-    latestMapping = await readWorkflowPoolRunMapping({
-      env: input.env,
-      runId: input.runId,
-    });
-    if (
-      latestMapping.instanceId === input.instanceId &&
-      latestMapping.startedAt !== null
-    ) {
-      return {
-        acknowledged: true,
-        ms: Date.now() - startedAt,
-        polls,
-        startedAt: latestMapping.startedAt,
-        mappedInstanceId: latestMapping.instanceId,
-      };
-    }
-    await sleep(WORKFLOW_POOL_START_ACK_POLL_MS);
-  }
-  return {
-    acknowledged: false,
-    ms: Date.now() - startedAt,
-    polls,
-    startedAt: latestMapping.startedAt,
-    mappedInstanceId: latestMapping.instanceId,
-  };
-}
-
-async function resolveWorkflowInstanceIdForRun(
-  env: CoordinatorEnv,
-  runId: string,
-): Promise<string> {
-  if (!workflowPoolEnabled()) {
-    return workflowInstanceId(runId);
-  }
-  const mapping = await readWorkflowPoolRunMapping({ env, runId });
-  return mapping.instanceId ? mapping.instanceId : workflowInstanceId(runId);
-}
-
-async function clearWorkflowPool(env: CoordinatorEnv): Promise<number> {
-  const entries = await listWorkflowPoolEntries(env).catch(() => []);
-  const body = await callWorkflowPool<{ deleted?: unknown }>(
-    env,
-    `/pool-clear?version=${encodeURIComponent(WORKFLOW_POOL_PROTOCOL_VERSION)}`,
-    { method: 'POST', body: '{}' },
-  );
-  await Promise.all(
-    entries.map(async (entry) => {
-      const instance = await getWorkflowPoolInstance(env, entry.id);
-      if (!instance) {
-        return;
-      }
-      try {
-        await instance.terminate().catch(() => undefined);
-      } finally {
-        disposeRpcStub(instance);
-      }
-    }),
-  );
-  return typeof body.deleted === 'number' ? body.deleted : 0;
-}
-
-function workflowStatusName(status: InstanceStatus | null): string {
-  return typeof status?.status === 'string' ? status.status : 'unknown';
-}
-
-function isWorkflowInstanceNotFoundError(error: unknown): boolean {
-  const message = error instanceof Error ? error.message : String(error);
-  return /not[ _]found|not_found|does not exist|no such instance|404/i.test(
-    message,
-  );
-}
-
-async function getWorkflowPoolInstance(
-  env: CoordinatorEnv,
-  instanceId: string,
-): Promise<WorkflowInstance | null> {
-  try {
-    return await env.PLAY_WORKFLOW.get(instanceId);
-  } catch (error) {
-    if (isWorkflowInstanceNotFoundError(error)) {
-      return null;
-    }
-    throw error;
-  }
-}
-
-function workflowPoolStatusIsReady(statusName: string): boolean {
-  // This is only a liveness guard. Readiness itself comes from the pooled
-  // Workflow calling /pool-ready after waitForEvent("play_start") has been
-  // created, because Cloudflare may report an armed wait as "running".
-  return statusName === 'running' || statusName === 'waiting';
-}
-
-async function waitForWorkflowPoolReadySignal(input: {
-  env: CoordinatorEnv;
-  instance: WorkflowInstance;
-  poolId: string;
-}): Promise<{
-  ready: boolean;
-  status: string;
-  ms: number;
-  polls: number;
-}> {
-  const startedAt = Date.now();
-  let lastStatusName = 'unknown';
-  let polls = 0;
-  while (Date.now() - startedAt < WORKFLOW_POOL_READY_TIMEOUT_MS) {
-    polls += 1;
-    const [entry, status] = await Promise.all([
-      listWorkflowPoolEntries(input.env)
-        .then((entries) =>
-          entries.find((candidate) => candidate.id === input.poolId),
-        )
-        .catch(() => undefined),
-      input.instance.status().catch(() => null),
-    ]);
-    const statusName = workflowStatusName(status);
-    lastStatusName = statusName;
-    if (entry?.state === 'ready' && entry.readyAt !== null) {
-      return {
-        ready: true,
-        status: statusName,
-        ms: Date.now() - startedAt,
-        polls,
-      };
-    }
-    if (
-      statusName === 'complete' ||
-      statusName === 'errored' ||
-      statusName === 'terminated' ||
-      statusName === 'unknown'
-    ) {
-      return {
-        ready: false,
-        status: statusName,
-        ms: Date.now() - startedAt,
-        polls,
-      };
-    }
-    await sleep(WORKFLOW_POOL_READY_POLL_MS);
-  }
-  return {
-    ready: false,
-    status: lastStatusName,
-    ms: Date.now() - startedAt,
-    polls,
-  };
-}
-
-async function refillWorkflowPoolOnce(
-  env: CoordinatorEnv,
-): Promise<Omit<WorkflowPoolRefillResult, 'waitedMs' | 'waitIterations'>> {
-  if (!workflowPoolEnabled()) {
-    return {
-      available: 0,
-      warming: 0,
-      target: 0,
-      created: 0,
-      promoted: 0,
-      removed: 0,
-    };
-  }
-  const target = workflowPoolTargetSize();
-  const entries = await listWorkflowPoolEntries(env);
-  const warmingEntries = entries.filter((entry) => entry.readyAt === null);
-  const promotedIds: string[] = [];
-  const removedIds: string[] = [];
-  for (const entry of warmingEntries) {
-    const instance = await getWorkflowPoolInstance(env, entry.id);
-    if (!instance) {
-      removedIds.push(entry.id);
-      continue;
-    }
-    try {
-      if (entry.state === 'ready' && entry.readyAt !== null) {
-        promotedIds.push(entry.id);
-        continue;
-      }
-      const status = await instance.status().catch(() => null);
-      const statusName = workflowStatusName(status);
-      if (
-        statusName === 'complete' ||
-        statusName === 'errored' ||
-        statusName === 'terminated' ||
-        statusName === 'unknown'
-      ) {
-        removedIds.push(entry.id);
-      }
-    } finally {
-      disposeRpcStub(instance);
-    }
-  }
-  await Promise.all([
-    promoteWorkflowPoolIds(env, promotedIds),
-    deleteWorkflowPoolIds(env, removedIds),
-  ]);
-  const counts = await workflowPoolCount(env);
-  const totalTracked = counts.available + counts.warming;
-  const needed = Math.max(0, target - totalTracked);
-  if (needed === 0) {
-    return {
-      available: counts.available,
-      warming: counts.warming,
-      target,
-      created: 0,
-      promoted: promotedIds.length,
-      removed: removedIds.length,
-    };
-  }
-  const created = await Promise.all(
-    Array.from({ length: needed }, async () => {
-      const poolId = `pool-v2-${Date.now().toString(36)}-${crypto.randomUUID().slice(0, 12)}`;
-      await addWorkflowPoolIds(env, [poolId], { ready: false });
-      const instance = await env.PLAY_WORKFLOW.create({
-        id: poolId,
-        params: {
-          __deeplinePooledWorkflow: true,
-          poolId,
-          createdAt: Date.now(),
-        } satisfies PooledWorkflowBootstrapPayload,
-      });
-      try {
-        const readiness = await waitForWorkflowPoolReadySignal({
-          env,
-          instance,
-          poolId,
-        });
-        recordCoordinatorPerfTrace({
-          runId: poolId,
-          phase: 'coordinator.workflow_pool_ready',
-          ms: readiness.ms,
-          graphHash: 'workflow-pool',
-          extra: {
-            ready: readiness.ready,
-            status: readiness.status,
-            polls: readiness.polls,
-          },
-        });
-        if (readiness.ready) {
-          return { id: poolId, state: 'ready' as const };
-        }
-        if (
-          readiness.status === 'complete' ||
-          readiness.status === 'errored' ||
-          readiness.status === 'terminated' ||
-          readiness.status === 'unknown'
-        ) {
-          await instance.terminate().catch(() => undefined);
-          return { id: poolId, state: 'removed' as const };
-        }
-        return { id: poolId, state: 'warming' as const };
-      } finally {
-        disposeRpcStub(instance);
-      }
-    }),
-  );
-  const readyCreatedIds = created
-    .filter((entry) => entry.state === 'ready')
-    .map((entry) => entry.id);
-  const warmingCreatedIds = created
-    .filter((entry) => entry.state === 'warming')
-    .map((entry) => entry.id);
-  removedIds.push(
-    ...created
-      .filter((entry) => entry.state === 'removed')
-      .map((entry) => entry.id),
-  );
-  await Promise.all([
-    addWorkflowPoolIds(env, readyCreatedIds, { ready: true }),
-    addWorkflowPoolIds(env, warmingCreatedIds, { ready: false }),
-  ]);
-  const finalCounts = await workflowPoolCount(env);
-  return {
-    available: finalCounts.available,
-    warming: finalCounts.warming,
-    target,
-    created: readyCreatedIds.length + warmingCreatedIds.length,
-    promoted: promotedIds.length,
-    removed: removedIds.length,
-  };
-}
-
-async function refillWorkflowPool(
-  env: CoordinatorEnv,
-  options?: {
-    minAvailable?: number;
-    waitReady?: boolean;
-    waitTimeoutMs?: number;
-  },
-): Promise<WorkflowPoolRefillResult> {
-  const startedAt = Date.now();
-  const minAvailable = Math.max(1, Math.floor(options?.minAvailable ?? 1));
-  const waitReady = options?.waitReady === true;
-  const waitTimeoutMs =
-    typeof options?.waitTimeoutMs === 'number' &&
-    Number.isFinite(options.waitTimeoutMs) &&
-    options.waitTimeoutMs > 0
-      ? Math.min(Math.floor(options.waitTimeoutMs), 15_000)
-      : 4_000;
-  let totals = await refillWorkflowPoolOnce(env);
-  let iterations = 0;
-  const readyWaitStartedAt = Date.now();
-
-  while (
-    workflowPoolEnabled() &&
-    waitReady &&
-    totals.available < minAvailable &&
-    Date.now() - readyWaitStartedAt < waitTimeoutMs
-  ) {
-    iterations += 1;
-    await sleep(WORKFLOW_POOL_READY_POLL_MS);
-    const next = await refillWorkflowPoolOnce(env);
-    totals = {
-      ...next,
-      created: totals.created + next.created,
-      promoted: totals.promoted + next.promoted,
-      removed: totals.removed + next.removed,
-    };
-  }
-
-  const result: WorkflowPoolRefillResult = {
-    ...totals,
-    waitedMs: Date.now() - startedAt,
-    waitIterations: iterations,
-  };
-  recordCoordinatorPerfTrace({
-    runId: 'workflow-pool',
-    phase: 'coordinator.workflow_pool_refill',
-    ms: result.waitedMs,
-    graphHash: 'workflow-pool',
-    extra: result,
-  });
-  return result;
-}
-
-async function submitViaPooledWorkflow(input: {
-  env: CoordinatorEnv;
-  params: PlayWorkflowParams;
-  recordSubmitTiming: (timing: CoordinatorTiming) => void;
-}): Promise<WorkflowInstance | null> {
-  if (!workflowPoolEnabled()) {
-    return null;
-  }
-  const leaseStartedAt = Date.now();
-  let leaseError: string | null = null;
-  const pooledInstanceId = await leaseWorkflowPoolId(
-    input.env,
-    input.params.runId,
-  ).catch((error) => {
-    leaseError = error instanceof Error ? error.message : String(error);
-    return null;
-  });
-  const missCounts = pooledInstanceId
-    ? null
-    : await workflowPoolCount(input.env).catch(() => null);
-  input.recordSubmitTiming({
-    phase: 'coordinator.workflow_pool_lease',
-    ms: Date.now() - leaseStartedAt,
-    graphHash: input.params.graphHash ?? null,
-    extra: {
-      pooled: Boolean(pooledInstanceId),
-      ...(leaseError ? { error: leaseError } : {}),
-      ...(missCounts
-        ? {
-            availableAfterMiss: missCounts.available,
-            warmingAfterMiss: missCounts.warming,
-          }
-        : {}),
-    },
-  });
-
-  if (!pooledInstanceId) {
-    // A pool miss must not block the user path. Refilling is handled by the
-    // caller's waitUntil after submit, so fall through to cold create now.
-    const counts =
-      missCounts ?? (await workflowPoolCount(input.env).catch(() => null));
-    input.recordSubmitTiming({
-      phase: 'coordinator.workflow_pool_refill_on_miss',
-      ms: 0,
-      graphHash: input.params.graphHash ?? null,
-      extra: {
-        skipped: true,
-        reason: 'pool_miss_does_not_block_submit',
-        ...(counts
-          ? {
-              available: counts.available,
-              warming: counts.warming,
-              waitedMs: 0,
-              waitIterations: 0,
-            }
-          : {}),
-      },
-    });
-  }
-
-  if (!pooledInstanceId) {
-    return null;
-  }
-
-  const instance = await getWorkflowPoolInstance(input.env, pooledInstanceId);
-  if (!instance) {
-    await blockWorkflowPoolRun({
-      env: input.env,
-      runId: input.params.runId,
-      instanceId: pooledInstanceId,
-    }).catch(() => undefined);
-    input.recordSubmitTiming({
-      phase: 'coordinator.workflow_pool_ready_check',
-      ms: Date.now() - leaseStartedAt,
-      graphHash: input.params.graphHash ?? null,
-      extra: { instanceId: pooledInstanceId, status: 'missing' },
-    });
-    return null;
-  }
-  const readyCheckStartedAt = Date.now();
-  const status = await instance.status().catch(() => null);
-  const statusName = workflowStatusName(status);
-  input.recordSubmitTiming({
-    phase: 'coordinator.workflow_pool_ready_check',
-    ms: Date.now() - readyCheckStartedAt,
-    graphHash: input.params.graphHash ?? null,
-    extra: { instanceId: pooledInstanceId, status: statusName },
-  });
-  if (!workflowPoolStatusIsReady(statusName)) {
-    await blockWorkflowPoolRun({
-      env: input.env,
-      runId: input.params.runId,
-      instanceId: pooledInstanceId,
-    }).catch(() => undefined);
-    await instance.terminate().catch(() => undefined);
-    disposeRpcStub(instance);
+    });
     return null;
+  });
+  if (!claim?.claimed || !claim.params) {
+    return { retried: false, result: null };
   }
-  const sendStartedAt = Date.now();
+  const retryInstanceId = workflowRetryInstanceId(input.runId, claim.attempts);
+  const retryStartedAt = Date.now();
+  let retryInstance: WorkflowInstance | null = null;
   try {
-    await instance.sendEvent({
-      type: WORKFLOW_POOL_START_EVENT_TYPE,
-      payload: buildDispatcherEnvelope(input.params),
+    retryInstance = await createDynamicWorkflowInstance({
+      env: input.env,
+      id: retryInstanceId,
+      params: claim.params,
     });
-  } catch (error) {
-    await blockWorkflowPoolRun({
+    await recordWorkflowInstanceId({
       env: input.env,
-      runId: input.params.runId,
-      instanceId: pooledInstanceId,
-    }).catch(() => undefined);
-    disposeRpcStub(instance);
-    console.warn('[coordinator.workflow_pool] sendEvent failed; falling back', {
-      runId: input.params.runId,
-      pooledInstanceId,
-      error: error instanceof Error ? error.message : String(error),
+      runId: input.runId,
+      instanceId: retryInstance.id,
     });
-    return null;
-  }
-  input.recordSubmitTiming({
-    phase: 'coordinator.workflow_pool_send_event',
-    ms: Date.now() - sendStartedAt,
-    graphHash: input.params.graphHash ?? null,
-    extra: { instanceId: pooledInstanceId },
-  });
-  const ack = await waitForWorkflowPoolStartAck({
-    env: input.env,
-    runId: input.params.runId,
-    instanceId: pooledInstanceId,
-    timeoutMs: WORKFLOW_POOL_START_ACK_TIMEOUT_MS,
-  });
-  if (ack.acknowledged) {
-    input.recordSubmitTiming({
-      phase: 'coordinator.workflow_pool_start_ack',
-      ms: ack.ms,
-      graphHash: input.params.graphHash ?? null,
+    input.ctx?.waitUntil(input.oldInstance.terminate().catch(() => undefined));
+    recordCoordinatorPerfTraceBuffered(input.env, input.ctx, {
+      runId: input.runId,
+      phase: 'coordinator.platform_deploy_retry',
+      ms: Date.now() - retryStartedAt,
+      graphHash: claim.params.graphHash ?? null,
       extra: {
-        acknowledged: true,
-        instanceId: pooledInstanceId,
-        polls: ack.polls,
-        startedAt: ack.startedAt,
+        retryAttempt: claim.attempts,
+        retryInstanceId: retryInstance.id,
+        reason: decision.reason,
       },
     });
-    return instance;
-  }
-
-  const blockStartedAt = Date.now();
-  const block = await blockWorkflowPoolRun({
-    env: input.env,
-    runId: input.params.runId,
-    instanceId: pooledInstanceId,
-  }).catch(() => ({ blocked: false, started: false }));
-  input.recordSubmitTiming({
-    phase: 'coordinator.workflow_pool_start_ack',
-    ms: ack.ms,
-    graphHash: input.params.graphHash ?? null,
-    extra: {
-      acknowledged: block.started,
-      instanceId: pooledInstanceId,
-      polls: ack.polls,
-      startedAt: ack.startedAt,
-      mappedInstanceId: ack.mappedInstanceId,
-      blocked: block.blocked,
-      blockMs: Date.now() - blockStartedAt,
-    },
-  });
-  if (block.started) {
-    return instance;
-  }
-  await instance.terminate().catch(() => undefined);
-  disposeRpcStub(instance);
-  input.recordSubmitTiming({
-    phase: 'coordinator.workflow_pool_fallback',
-    ms: Date.now() - sendStartedAt,
-    graphHash: input.params.graphHash ?? null,
-    extra: {
-      reason: 'start_ack_timeout',
-      instanceId: pooledInstanceId,
-      ackTimeoutMs: WORKFLOW_POOL_START_ACK_TIMEOUT_MS,
-    },
-  });
-  return null;
-}
-
-function readWorkflowPayload(event: unknown): Record<string, unknown> | null {
-  if (!isRecord(event)) return null;
-  const payload = event.payload;
-  if (!isRecord(payload)) return null;
-  return isRecord(payload.params) ? payload.params : payload;
-}
-
-async function markWorkflowRuntimeFailure(input: {
-  env: CoordinatorEnv;
-  event: unknown;
-  error: unknown;
-}): Promise<void> {
-  const payload = readWorkflowPayload(input.event);
-  if (!payload) return;
-  const runId = typeof payload.runId === 'string' ? payload.runId : null;
-  const baseUrl = typeof payload.baseUrl === 'string' ? payload.baseUrl : null;
-  const executorToken =
-    typeof payload.executorToken === 'string' ? payload.executorToken : null;
-  if (!runId || !baseUrl || !executorToken) return;
-  const errorName =
-    input.error instanceof Error && input.error.name
-      ? input.error.name
-      : 'Error';
-  const errorMessage =
-    input.error instanceof Error ? input.error.message : String(input.error);
-  const errorStack =
-    input.error instanceof Error && typeof input.error.stack === 'string'
-      ? input.error.stack.split('\n').slice(0, 12).join('\n')
-      : null;
-  const headers = new Headers({
-    authorization: `Bearer ${executorToken}`,
-    'content-type': 'application/json',
-  });
-  const bypass = input.env.VERCEL_PROTECTION_BYPASS_TOKEN?.trim();
-  if (bypass) headers.set('x-vercel-protection-bypass', bypass);
-  const body = JSON.stringify({
-    action: 'append_run_events',
-    playId: runId,
-    events: [
-      {
-        type: 'run.failed',
-        runId,
-        source: 'coordinator',
-        occurredAt: Date.now(),
-        error: `DynamicWorkflow runner failed: ${errorName}: ${errorMessage}${
-          errorStack ? `\n${errorStack}` : ''
-        }`,
-      } satisfies PlayRunLedgerEvent,
-    ],
-  });
-  const url = `${baseUrl.replace(/\/$/, '')}/api/v2/plays/internal/runtime`;
-  const backoffMs = [200, 500, 1500];
-  let lastError: unknown = null;
-  for (let attempt = 0; attempt <= backoffMs.length; attempt += 1) {
-    try {
-      const response = await fetch(url, { method: 'POST', headers, body });
-      if (response.ok) return;
-      lastError = new Error(
-        `runtime API responded ${response.status}: ${(await response.text().catch(() => '')).slice(0, 400)}`,
-      );
-      if (
-        response.status >= 400 &&
-        response.status < 500 &&
-        response.status !== 408 &&
-        response.status !== 429
-      ) {
-        break;
-      }
-    } catch (error) {
-      lastError = error;
-    }
-    if (attempt < backoffMs.length) {
-      await new Promise((resolve) => setTimeout(resolve, backoffMs[attempt]));
-    }
+    return {
+      retried: true,
+      result: {
+        runId: input.runId,
+        playName: claim.params.playName,
+        status: 'running',
+        result: null,
+        error: null,
+        retry: {
+          reason: decision.reason,
+          attempt: claim.attempts,
+          message: decision.message,
+        },
+      },
+    };
+  } finally {
+    disposeRpcStub(retryInstance);
   }
-  console.error('[coordinator] failed to mark workflow runtime failure', {
-    runId,
-    message: lastError instanceof Error ? lastError.message : String(lastError),
-  });
 }
 
-type StoredPlayArtifactPayload = {
-  artifact?: {
-    bundledCode?: string;
-    artifactKind?: string;
-  };
-};
-
-const DYNAMIC_WORKER_COMPATIBILITY_DATE = '2026-05-01';
-
 async function mintChildWorkflowExecutorToken(input: {
   env: CoordinatorEnv;
-  baseUrl: string;
   parentExecutorToken: string;
   parentRunId: string;
   parentPlayName: string;
@@ -1993,37 +1432,27 @@ async function mintChildWorkflowExecutorToken(input: {
   childPlayName: string;
   maxCreditsPerRun?: number | null;
 }): Promise<string> {
-  const url = `${input.baseUrl.replace(/\/$/, '')}/api/v2/plays/internal/child-executor-token`;
-  const headers = new Headers({
-    authorization: `Bearer ${input.parentExecutorToken}`,
-    'content-type': 'application/json',
-    'x-deepline-request-id': crypto.randomUUID(),
-  });
-  if (input.env.VERCEL_PROTECTION_BYPASS_TOKEN?.trim()) {
-    headers.set(
-      'x-vercel-protection-bypass',
-      input.env.VERCEL_PROTECTION_BYPASS_TOKEN.trim(),
-    );
-  }
-  const response = await fetch(url, {
-    method: 'POST',
-    headers,
-    body: JSON.stringify({
+  const response = await input.env.HARNESS.runtimeApiCall({
+    executorToken: input.parentExecutorToken,
+    path: '/api/v2/plays/internal/child-executor-token',
+    headers: { 'x-deepline-request-id': crypto.randomUUID() },
+    timeoutMs: 15_000,
+    body: {
       parentRunId: input.parentRunId,
       parentPlayName: input.parentPlayName,
       childRunId: input.childRunId,
       childPlayName: input.childPlayName,
       maxCreditsPerRun: input.maxCreditsPerRun ?? null,
-    }),
+    },
   });
-  const text = await response.text().catch(() => '');
+  const text = response.body;
   let parsed: Record<string, unknown> = {};
   try {
     parsed = text ? (JSON.parse(text) as Record<string, unknown>) : {};
   } catch {
     parsed = {};
   }
-  if (!response.ok) {
+  if (response.status < 200 || response.status >= 300) {
     const error = isRecord(parsed.error) ? parsed.error : null;
     const message =
       (typeof error?.message === 'string' && error.message.trim()) ||
@@ -2106,7 +1535,6 @@ async function reencryptChildDbSessionForExecutor(input: {
 
 async function createChildRuntimeDbSession(input: {
   env: CoordinatorEnv;
-  baseUrl: string;
   childExecutorToken: string;
   childPlayName: string;
   requirement: RuntimeDbSessionRequirement;
@@ -2114,22 +1542,12 @@ async function createChildRuntimeDbSession(input: {
   orgId: string;
 }): Promise<CreateDbSessionResponse> {
   const decryptionKey = await generateDbSessionPostgresUrlDecryptionKey();
-  const url = `${input.baseUrl.replace(/\/$/, '')}/api/v2/plays/internal/runtime`;
-  const headers = new Headers({
-    authorization: `Bearer ${input.childExecutorToken}`,
-    'content-type': 'application/json',
-    'x-deepline-request-id': crypto.randomUUID(),
-  });
-  if (input.env.VERCEL_PROTECTION_BYPASS_TOKEN?.trim()) {
-    headers.set(
-      'x-vercel-protection-bypass',
-      input.env.VERCEL_PROTECTION_BYPASS_TOKEN.trim(),
-    );
-  }
-  const response = await fetch(url, {
-    method: 'POST',
-    headers,
-    body: JSON.stringify({
+  const response = await input.env.HARNESS.runtimeApiCall({
+    executorToken: input.childExecutorToken,
+    path: '/api/v2/plays/internal/runtime',
+    headers: { 'x-deepline-request-id': crypto.randomUUID() },
+    timeoutMs: 15_000,
+    body: {
       action: 'create_db_session',
       playName: input.childPlayName,
       target: {
@@ -2142,16 +1560,16 @@ async function createChildRuntimeDbSession(input: {
       ttlSeconds: DB_SESSION_DEFAULT_TTL_SECONDS,
       userEmail: input.userEmail,
       postgresUrlEncryption: decryptionKey.request,
-    }),
+    },
   });
-  const text = await response.text().catch(() => '');
+  const text = response.body;
   let parsed: unknown = {};
   try {
     parsed = text ? JSON.parse(text) : {};
   } catch {
     parsed = {};
   }
-  if (!response.ok) {
+  if (response.status < 200 || response.status >= 300) {
     const error =
       isRecord(parsed) && isRecord(parsed.error) ? parsed.error : {};
     const message =
@@ -2172,52 +1590,224 @@ async function createChildRuntimeDbSession(input: {
     orgId: input.orgId,
     childPlayName: input.childPlayName,
   });
-  return await reencryptChildDbSessionForExecutor({
-    session,
-    decryptionKey,
-    childExecutorToken: input.childExecutorToken,
+  return await reencryptChildDbSessionForExecutor({
+    session,
+    decryptionKey,
+    childExecutorToken: input.childExecutorToken,
+  });
+}
+
+async function preloadChildRuntimeDbSessions(input: {
+  env: CoordinatorEnv;
+  childExecutorToken: string;
+  childRunId: string;
+  childPlayName: string;
+  manifest: PlayRuntimeManifest;
+  orgId: string;
+  userEmail: string;
+}): Promise<PreloadedRuntimeDbSession[]> {
+  const startedAt = Date.now();
+  const requirements = planRuntimeDbSessionRequirements(
+    input.manifest.staticPipeline ?? null,
+  );
+  const sessions = await Promise.all(
+    requirements.map(async (requirement) => ({
+      tableNamespace: requirement.tableNamespace,
+      logicalTable: requirement.logicalTable,
+      operations: requirement.operations,
+      ...(requirement.limits ? { limits: requirement.limits } : {}),
+      session: await createChildRuntimeDbSession({
+        env: input.env,
+        childExecutorToken: input.childExecutorToken,
+        childPlayName: input.childPlayName,
+        requirement,
+        userEmail: input.userEmail,
+        orgId: input.orgId,
+      }),
+    })),
+  );
+  recordCoordinatorPerfTrace({
+    runId: input.childRunId,
+    phase: 'coordinator.child_db_session_preload',
+    ms: Date.now() - startedAt,
+    graphHash: input.manifest.graphHash,
+    extra: { sessions: sessions.length },
+  });
+  return sessions;
+}
+
+async function registerInlineChildRunWithRuntime(input: {
+  env: CoordinatorEnv;
+  childExecutorToken: string;
+  childRunId: string;
+  childPlayName: string;
+  manifest: PlayRuntimeManifest;
+  governance: PlayCallGovernanceSnapshot;
+}): Promise<void> {
+  const response = await input.env.HARNESS.runtimeApiCall({
+    executorToken: input.childExecutorToken,
+    path: '/api/v2/plays/internal/runtime',
+    headers: { 'x-deepline-request-id': crypto.randomUUID() },
+    timeoutMs: 15_000,
+    body: {
+      action: 'start_inline_child_run',
+      playName: input.childPlayName,
+      runId: input.childRunId,
+      workflowFamilyKey:
+        input.governance.rootRunId ??
+        input.governance.parentRunId ??
+        input.childRunId,
+      artifactStorageKey: input.manifest.artifactStorageKey,
+      artifactHash: input.manifest.artifactHash,
+      graphHash: input.manifest.graphHash,
+      runtimeBackend: 'workers_edge',
+      schedulerBackend: 'inline_child',
+      executionProfile: 'workers_edge',
+      ...(typeof input.manifest.maxCreditsPerRun === 'number'
+        ? { maxCreditsPerRun: input.manifest.maxCreditsPerRun }
+        : {}),
+      staticPipeline: input.manifest.staticPipeline ?? null,
+      source: 'published',
+    },
+  });
+  if (response.status < 200 || response.status >= 300) {
+    const text = response.body ?? '';
+    throw new Error(
+      `Inline child run registration failed ${response.status}: ${text.slice(0, 800)}`,
+    );
+  }
+}
+
+type CoordinatorRuntimeApiTiming = {
+  phase: string;
+  ms: number;
+  bytes?: number;
+};
+
+async function callRuntimeApiFromCoordinator(input: {
+  env: CoordinatorEnv;
+  executorToken: string;
+  body: unknown;
+}): Promise<{
+  status: number;
+  body: string;
+  timings: CoordinatorRuntimeApiTiming[];
+}> {
+  const timings: CoordinatorRuntimeApiTiming[] = [];
+  const totalStartedAt = Date.now();
+  const recordTiming = (
+    phase: string,
+    startedAt: number,
+    extra?: { bytes?: number },
+  ): void => {
+    timings.push({
+      phase,
+      ms: Date.now() - startedAt,
+      ...(extra?.bytes !== undefined ? { bytes: extra.bytes } : {}),
+    });
+  };
+
+  const buildStartedAt = Date.now();
+  const body = input.body ?? {};
+  const serializedBody = JSON.stringify(body);
+  recordTiming('coordinator.runtime_api.build_request', buildStartedAt, {
+    bytes: serializedBody.length,
+  });
+
+  const fetchStartedAt = Date.now();
+  const response = await input.env.HARNESS.runtimeApiCall({
+    executorToken: input.executorToken,
+    path: '/api/v2/plays/internal/runtime',
+    body,
+    headers: {
+      'x-deepline-request-id': crypto.randomUUID(),
+    },
+  });
+  recordTiming('coordinator.runtime_api.fetch', fetchStartedAt);
+
+  const bodyStartedAt = Date.now();
+  const responseBody = response.body;
+  recordTiming('coordinator.runtime_api.body', bodyStartedAt, {
+    bytes: responseBody.length,
   });
+  recordTiming('coordinator.runtime_api.total', totalStartedAt);
+  return {
+    status: response.status,
+    body: responseBody,
+    timings,
+  };
 }
 
-async function preloadChildRuntimeDbSessions(input: {
+async function prepareInlineChildRunWithRuntime(input: {
   env: CoordinatorEnv;
-  baseUrl: string;
-  childExecutorToken: string;
+  parentExecutorToken: string;
+  parentRunId: string;
+  parentPlayName: string;
   childRunId: string;
   childPlayName: string;
   manifest: PlayRuntimeManifest;
-  orgId: string;
+  governance: PlayCallGovernanceSnapshot;
   userEmail: string;
-}): Promise<PreloadedRuntimeDbSession[]> {
-  const startedAt = Date.now();
-  const requirements = planRuntimeDbSessionRequirements(
-    input.manifest.staticPipeline ?? null,
-  );
-  const sessions = await Promise.all(
-    requirements.map(async (requirement) => ({
-      tableNamespace: requirement.tableNamespace,
-      logicalTable: requirement.logicalTable,
-      operations: requirement.operations,
-      ...(requirement.limits ? { limits: requirement.limits } : {}),
-      session: await createChildRuntimeDbSession({
-        env: input.env,
-        baseUrl: input.baseUrl,
-        childExecutorToken: input.childExecutorToken,
-        childPlayName: input.childPlayName,
-        requirement,
-        userEmail: input.userEmail,
-        orgId: input.orgId,
-      }),
-    })),
-  );
-  recordCoordinatorPerfTrace({
-    runId: input.childRunId,
-    phase: 'coordinator.child_db_session_preload',
-    ms: Date.now() - startedAt,
-    graphHash: input.manifest.graphHash,
-    extra: { sessions: sessions.length },
+}): Promise<{
+  childToken: string;
+  preloadedDbSessions: PreloadedRuntimeDbSession[];
+  prepareTimings: unknown[];
+  transportTimings: unknown[];
+}> {
+  const response = await callRuntimeApiFromCoordinator({
+    env: input.env,
+    executorToken: input.parentExecutorToken,
+    body: {
+      action: 'prepare_inline_child_run',
+      parentRunId: input.parentRunId,
+      parentPlayName: input.parentPlayName,
+      childRunId: input.childRunId,
+      childPlayName: input.childPlayName,
+      workflowFamilyKey:
+        input.governance.rootRunId ??
+        input.governance.parentRunId ??
+        input.childRunId,
+      artifactStorageKey: input.manifest.artifactStorageKey,
+      artifactHash: input.manifest.artifactHash,
+      graphHash: input.manifest.graphHash,
+      runtimeBackend: 'workers_edge',
+      schedulerBackend: 'inline_child',
+      executionProfile: 'workers_edge',
+      ...(typeof input.manifest.maxCreditsPerRun === 'number'
+        ? { maxCreditsPerRun: input.manifest.maxCreditsPerRun }
+        : {}),
+      staticPipeline: input.manifest.staticPipeline ?? null,
+      source: 'published',
+      userEmail: input.userEmail,
+    },
   });
-  return sessions;
+  const text = response.body;
+  let parsed: unknown = {};
+  try {
+    parsed = text ? JSON.parse(text) : {};
+  } catch {
+    parsed = {};
+  }
+  if (response.status < 200 || response.status >= 300) {
+    throw new Error(
+      `Inline child prepare failed ${response.status}: ${text.slice(0, 800)}`,
+    );
+  }
+  if (!isRecord(parsed) || typeof parsed.executorToken !== 'string') {
+    throw new Error('Inline child prepare response was missing executorToken.');
+  }
+  const preloadedDbSessions = Array.isArray(parsed.preloadedDbSessions)
+    ? (parsed.preloadedDbSessions as PreloadedRuntimeDbSession[])
+    : [];
+  const prepareTimings = Array.isArray(parsed.prepareTimings)
+    ? parsed.prepareTimings
+    : [];
+  return {
+    childToken: parsed.executorToken,
+    preloadedDbSessions,
+    prepareTimings,
+    transportTimings: response.timings,
+  };
 }
 
 function buildChildRunId(playName: string): string {
@@ -2476,6 +2066,8 @@ function runRequestFromPlayWorkflowParams(
     childPlayManifests: params.childPlayManifests ?? null,
     playCallGovernance: params.playCallGovernance ?? null,
     preloadedDbSessions: params.preloadedDbSessions ?? null,
+    inlineChildRunRegistered:
+      params.runtimeBackend === 'cf_workflows_dynamic_worker_inline_child',
     coordinatorUrl: params.coordinatorUrl ?? null,
     totalRows: params.totalRows,
   };
@@ -2606,38 +2198,41 @@ async function executeChildInline(input: {
     },
   });
 
-  const tokenStartedAt = Date.now();
-  const baseUrl = resolveRuntimeBaseUrl(input.env, input.body);
-  const childToken = await mintChildWorkflowExecutorToken({
-    env: input.env,
-    baseUrl,
-    parentExecutorToken,
-    parentRunId: input.parentRunId,
-    parentPlayName:
-      typeof input.body.parentPlayName === 'string' &&
-      input.body.parentPlayName.trim()
-        ? input.body.parentPlayName.trim()
-        : governance.parentPlayName,
-    childRunId,
-    childPlayName,
-    maxCreditsPerRun: manifest.maxCreditsPerRun ?? null,
+  const loaderStartedAt = Date.now();
+  const stub = loadDynamicPlayWorker(input.env, {
+    runId: childRunId,
+    graphHash: manifest.graphHash,
+    artifactStorageKey: manifest.artifactStorageKey,
+    artifactHash: manifest.artifactHash,
+    dynamicWorkerCode:
+      typeof manifest.bundledCode === 'string' ? manifest.bundledCode : null,
+    packagedFiles: null,
   });
-  trace('coordinator.inline_child_token', tokenStartedAt);
+  trace('coordinator.inline_child_loader_get', loaderStartedAt);
 
-  const dbSessionStartedAt = Date.now();
-  const preloadedDbSessions = await preloadChildRuntimeDbSessions({
-    env: input.env,
-    baseUrl,
-    childExecutorToken: childToken,
-    childRunId,
-    childPlayName,
-    manifest,
-    orgId,
-    userEmail:
-      typeof input.body.userEmail === 'string' ? input.body.userEmail : '',
-  });
-  trace('coordinator.inline_child_db_session_preload', dbSessionStartedAt, {
+  const prepareStartedAt = Date.now();
+  const parentPlayName =
+    typeof input.body.parentPlayName === 'string' &&
+    input.body.parentPlayName.trim()
+      ? input.body.parentPlayName.trim()
+      : governance.parentPlayName;
+  const { childToken, preloadedDbSessions, prepareTimings, transportTimings } =
+    await prepareInlineChildRunWithRuntime({
+      env: input.env,
+      parentExecutorToken,
+      parentRunId: input.parentRunId,
+      parentPlayName,
+      childRunId,
+      childPlayName,
+      manifest,
+      governance,
+      userEmail:
+        typeof input.body.userEmail === 'string' ? input.body.userEmail : '',
+    });
+  trace('coordinator.inline_child_prepare', prepareStartedAt, {
     sessions: preloadedDbSessions.length,
+    prepareTimings,
+    transportTimings,
   });
 
   const params = buildChildWorkflowParams({
@@ -2655,17 +2250,6 @@ async function executeChildInline(input: {
     preloadedDbSessions:
       preloadedDbSessions.length > 0 ? preloadedDbSessions : null,
   });
-  const loaderStartedAt = Date.now();
-  const stub = loadDynamicPlayWorker(input.env, {
-    runId: childRunId,
-    graphHash: manifest.graphHash,
-    artifactStorageKey: manifest.artifactStorageKey,
-    artifactHash: manifest.artifactHash,
-    dynamicWorkerCode:
-      typeof manifest.bundledCode === 'string' ? manifest.bundledCode : null,
-    packagedFiles: null,
-  });
-  trace('coordinator.inline_child_loader_get', loaderStartedAt);
 
   let entrypoint: ReturnType<Awaited<typeof stub>['getEntrypoint']> | null =
     null;
@@ -2676,44 +2260,54 @@ async function executeChildInline(input: {
     entrypoint = awaitedStub.getEntrypoint();
     trace('coordinator.inline_child_get_entrypoint', entrypointStartedAt);
     const fetchStartedAt = Date.now();
-    response = await entrypoint.fetch(
+    const inlineResponse = await entrypoint.fetch(
       new Request('https://deepline.dynamic.internal/run-inline', {
         method: 'POST',
         headers: { 'content-type': 'application/json' },
         body: JSON.stringify(runRequestFromPlayWorkflowParams(params)),
       }),
     );
+    if (!inlineResponse) {
+      throw new Error('Inline child Worker returned no response.');
+    }
+    let workerResponse = inlineResponse as Response;
+    response = workerResponse;
     trace('coordinator.inline_child_worker_fetch', fetchStartedAt, {
-      status: response.status,
+      status: workerResponse.status,
       endpoint: '/run-inline',
     });
     let usedLegacyRunStream = false;
-    if (response.status === 404) {
-      disposeRpcStub(response);
+    if (workerResponse.status === 404) {
+      disposeRpcStub(workerResponse);
       const legacyFetchStartedAt = Date.now();
-      response = await entrypoint.fetch(
+      const legacyResponse = await entrypoint.fetch(
         new Request('https://deepline.dynamic.internal/run', {
           method: 'POST',
           headers: { 'content-type': 'application/json' },
           body: JSON.stringify(runRequestFromPlayWorkflowParams(params)),
         }),
       );
+      if (!legacyResponse) {
+        throw new Error('Legacy inline child Worker returned no response.');
+      }
+      workerResponse = legacyResponse as Response;
+      response = workerResponse;
       usedLegacyRunStream = true;
       trace('coordinator.inline_child_worker_fetch', legacyFetchStartedAt, {
-        status: response.status,
+        status: workerResponse.status,
         endpoint: '/run',
         compatibility: 'legacy_stream',
       });
     }
-    if (!response.ok) {
-      const text = await response.text().catch(() => '');
+    if (!workerResponse.ok) {
+      const text = await workerResponse.text().catch(() => '');
       throw new Error(
-        `Inline child Worker failed ${response.status}: ${text.slice(0, 800)}`,
+        `Inline child Worker failed ${workerResponse.status}: ${text.slice(0, 800)}`,
       );
     }
     const responseStartedAt = Date.now();
     const parsed: InlineWorkerRunResponse = usedLegacyRunStream
-      ? await readLegacyRunStream(response).then((legacy) => ({
+      ? await readLegacyRunStream(workerResponse).then((legacy) => ({
           status: legacy.error ? 'failed' : 'completed',
           result: legacy.result,
           outputRows: legacy.outputRows ?? undefined,
@@ -2723,7 +2317,7 @@ async function executeChildInline(input: {
           })),
           error: legacy.error ?? undefined,
         }))
-      : ((await response.json()) as InlineWorkerRunResponse);
+      : ((await workerResponse.json()) as InlineWorkerRunResponse);
     const logs = (parsed.events ?? []).flatMap((event) => {
       if (
         event &&
@@ -2744,6 +2338,34 @@ async function executeChildInline(input: {
       durationMs:
         typeof parsed.durationMs === 'number' ? parsed.durationMs : null,
     });
+    for (const timing of parsed.timings ?? []) {
+      if (
+        !timing ||
+        typeof timing !== 'object' ||
+        typeof timing.phase !== 'string' ||
+        typeof timing.ms !== 'number' ||
+        !Number.isFinite(timing.ms)
+      ) {
+        continue;
+      }
+      recordCoordinatorPerfTrace({
+        runId: childRunId,
+        phase: `dynamic_worker.${timing.phase}`,
+        ms: Math.max(0, Math.round(timing.ms)),
+        graphHash: manifest.graphHash,
+        extra: {
+          parentRunId: input.parentRunId,
+          mode: 'inline_dynamic_worker',
+          ...(isRecord(timing.extra) ? timing.extra : {}),
+        },
+      });
+      timings.push({
+        phase: `dynamic_worker.${timing.phase}`,
+        ms: Math.max(0, Math.round(timing.ms)),
+        graphHash: manifest.graphHash,
+        ...(isRecord(timing.extra) ? { extra: timing.extra } : {}),
+      });
+    }
     trace('coordinator.inline_child_total', startedAt);
     if (parsed.status === 'failed' || parsed.error) {
       const error = {
@@ -2788,29 +2410,176 @@ async function executeChildInline(input: {
         action: 'completed',
         mode: 'inline_dynamic_worker',
       },
-    });
-    return {
-      workflowId: childRunId,
-      runId: childRunId,
-      status: 'completed',
-      mode: 'inline_dynamic_worker',
-      result: parsed.result,
-      output: parsed.result,
-      logs,
-      timings,
-    };
-  } finally {
-    disposeRpcStub(response);
-    disposeRpcStub(entrypoint);
-    disposeRpcStub(await stub.catch(() => null));
-  }
+    });
+    return {
+      workflowId: childRunId,
+      runId: childRunId,
+      status: 'completed',
+      mode: 'inline_dynamic_worker',
+      result: parsed.result,
+      output: parsed.result,
+      logs,
+      timings,
+    };
+  } finally {
+    disposeRpcStub(response);
+    disposeRpcStub(entrypoint);
+    disposeRpcStub(await stub.catch(() => null));
+  }
+}
+
+async function submitChildWorkflowThroughCoordinator(input: {
+  env: CoordinatorEnv;
+  parentRunId: string;
+  body: Record<string, unknown>;
+  coordinatorUrl: string | null;
+}): Promise<{
+  response: Response;
+  responseText: string;
+  childRunId: string;
+  childPlayName: string;
+  startedAt: number;
+  timings: CoordinatorTiming[];
+}> {
+  const startedAt = Date.now();
+  const timings: CoordinatorTiming[] = [];
+  const trace = (
+    phase: string,
+    phaseStartedAt: number,
+    graphHash?: string | null,
+    extra?: Record<string, unknown>,
+  ): void => {
+    const timing: CoordinatorTiming = {
+      phase,
+      ms: Date.now() - phaseStartedAt,
+      ...(graphHash ? { graphHash } : {}),
+      ...(extra ? { extra } : {}),
+    };
+    timings.push(timing);
+    recordCoordinatorPerfTrace({
+      runId: input.parentRunId,
+      phase,
+      ms: timing.ms,
+      graphHash: graphHash ?? undefined,
+      extra,
+    });
+  };
+  const validated = validateChildSubmitBody({
+    parentRunId: input.parentRunId,
+    body: input.body,
+  });
+  if (!validated.ok) {
+    return {
+      response: Response.json(
+        { error: validated.error },
+        { status: validated.status },
+      ),
+      responseText: '',
+      childRunId: '',
+      childPlayName: '',
+      startedAt,
+      timings,
+    };
+  }
+  const { manifest, governance, childPlayName, orgId, parentExecutorToken } =
+    validated;
+  const childRunId = buildChildRunId(childPlayName);
+  const baseUrl = resolveRuntimeBaseUrl(input.env, input.body);
+
+  const tokenStartedAt = Date.now();
+  const childToken = await mintChildWorkflowExecutorToken({
+    env: input.env,
+    parentExecutorToken,
+    parentRunId: input.parentRunId,
+    parentPlayName:
+      typeof input.body.parentPlayName === 'string' &&
+      input.body.parentPlayName.trim()
+        ? input.body.parentPlayName.trim()
+        : governance.parentPlayName,
+    childRunId,
+    childPlayName,
+    maxCreditsPerRun: manifest.maxCreditsPerRun ?? null,
+  });
+  trace('coordinator.child_submit_token', tokenStartedAt, manifest.graphHash, {
+    childRunId,
+    childPlayName,
+  });
+
+  const dbSessionStartedAt = Date.now();
+  const preloadedDbSessions = await preloadChildRuntimeDbSessions({
+    env: input.env,
+    childExecutorToken: childToken,
+    childRunId,
+    childPlayName,
+    manifest,
+    orgId,
+    userEmail:
+      typeof input.body.userEmail === 'string' ? input.body.userEmail : '',
+  });
+  trace(
+    'coordinator.child_submit_db_session_preload',
+    dbSessionStartedAt,
+    manifest.graphHash,
+    { childRunId, sessions: preloadedDbSessions.length },
+  );
+
+  const params = buildChildWorkflowParams({
+    env: input.env,
+    body: input.body,
+    manifest,
+    governance,
+    childRunId,
+    childPlayName,
+    childToken,
+    orgId,
+    coordinatorUrl: input.coordinatorUrl,
+    runtimeBackend: 'cf_workflows_dynamic_worker',
+    dynamicWorkerCode:
+      typeof manifest.bundledCode === 'string' ? manifest.bundledCode : null,
+    preloadedDbSessions:
+      preloadedDbSessions.length > 0 ? preloadedDbSessions : null,
+  });
+
+  const workflowSubmitStartedAt = Date.now();
+  const response = await handleWorkflowRoute({
+    runId: childRunId,
+    action: 'submit',
+    request: new Request(
+      `https://deepline.coordinator.internal/workflow/${encodeURIComponent(
+        childRunId,
+      )}/submit`,
+      {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify(params),
+      },
+    ),
+    env: input.env,
+  });
+  trace(
+    'coordinator.child_submit_workflow',
+    workflowSubmitStartedAt,
+    manifest.graphHash,
+    { childRunId, status: response.status },
+  );
+  const responseText = await response.text().catch(() => '');
+  return {
+    response,
+    responseText,
+    childRunId,
+    childPlayName,
+    startedAt,
+    timings,
+  };
 }
 
 /**
  * In-process Fetcher handed to each per-graphHash play Worker as
- * `env.RUNTIME_API`. Runs in the coordinator's isolate (not the play's), so
- * `fetch(target)` here can reach `http://localhost:3000` directly in dev —
- * no public *.workers.dev → CF edge → cloudflared → localhost chain.
+ * `env.RUNTIME_API`. Runs in the coordinator's isolate. Forwards runtime
+ * callbacks to DEEPLINE_API_BASE_URL: in dev (the only mode — deployed CF
+ * coordinator + local app) that is the cloudflared tunnel URL exposing the
+ * laptop's app; in prod it is the deployed app URL. There is no
+ * direct-to-localhost path (the local-workerd dev mode was removed).
  *
  * Has to be a `WorkerEntrypoint` (not a plain closure) because closures
  * containing captured state aren't structured-cloneable, and Cloudflare
@@ -2882,6 +2651,49 @@ export class CoordinatorControl extends WorkerEntrypoint<
     });
   }
 
+  async submitWorkflowChild(
+    parentRunId: string,
+    body: Record<string, unknown>,
+  ): Promise<{
+    workflowId?: string;
+    runId?: string;
+    status?: string;
+    mode?: string;
+    timings?: CoordinatorTiming[];
+    coordinator?: unknown;
+    error?: unknown;
+  }> {
+    const { response, responseText, childRunId, timings } =
+      await submitChildWorkflowThroughCoordinator({
+        env: this.env,
+        parentRunId,
+        body,
+        coordinatorUrl: null,
+      });
+    let parsed: unknown = {};
+    try {
+      parsed = responseText ? JSON.parse(responseText) : {};
+    } catch {
+      parsed = { error: responseText };
+    }
+    if (!response.ok) {
+      return {
+        runId: childRunId || undefined,
+        workflowId: childRunId || undefined,
+        status: 'failed',
+        error: isRecord(parsed) ? (parsed.error ?? parsed) : parsed,
+      };
+    }
+    return {
+      workflowId: childRunId,
+      runId: childRunId,
+      status: 'started',
+      mode: 'workflow_rpc',
+      coordinator: parsed,
+      timings,
+    };
+  }
+
   async signal(
     runId: string,
     body: Record<string, unknown>,
@@ -2942,6 +2754,75 @@ export class CoordinatorControl extends WorkerEntrypoint<
     }
     await appendCoordinatorRunEvent(this.env, event);
   }
+
+  async readTerminalState(
+    runId: string,
+  ): Promise<CoordinatorTerminalState | null> {
+    if (!runId) {
+      throw new Error('runId is required.');
+    }
+    return await readCoordinatorTerminalState(this.env, runId);
+  }
+
+  async readChildTerminalState(
+    parentRunId: string,
+    eventKey: string,
+    timeoutMs?: number,
+  ): Promise<CoordinatorChildTerminalState | null> {
+    if (!parentRunId || !eventKey) {
+      throw new Error('parentRunId and eventKey are required.');
+    }
+    return await readCoordinatorChildTerminalState({
+      env: this.env,
+      parentRunId,
+      eventKey,
+      timeoutMs:
+        typeof timeoutMs === 'number' && Number.isFinite(timeoutMs)
+          ? Math.max(0, Math.min(Math.floor(timeoutMs), 30_000))
+          : undefined,
+    });
+  }
+
+  /**
+   * Distributed Rate State Backend acquire: lease up to `requested` request-
+   * window permits for `bucketId` (`<orgId>:<provider>`) from the per-bucket
+   * rate-state Durable Object. See CoordinatorRateStateBackend + dedup-do.ts.
+   */
+  async rateAcquire(input: {
+    bucketId: string;
+    rules: Array<{
+      ruleId: string;
+      requestsPerWindow: number;
+      windowMs: number;
+      maxConcurrency: number | null;
+    }>;
+    requested: number;
+  }): Promise<{ granted: number; waitMs: number }> {
+    if (!input.bucketId || !input.bucketId.trim()) {
+      throw new Error('bucketId is required.');
+    }
+    return await callRateBucketControl<{ granted: number; waitMs: number }>(
+      this.env,
+      input.bucketId,
+      '/rate-acquire',
+      input,
+    );
+  }
+
+  async ratePenalize(input: {
+    bucketId: string;
+    cooldownMs: number;
+  }): Promise<void> {
+    if (!input.bucketId || !input.bucketId.trim()) {
+      throw new Error('bucketId is required.');
+    }
+    await callRateBucketControl<{ ok?: unknown }>(
+      this.env,
+      input.bucketId,
+      '/rate-penalize',
+      input,
+    );
+  }
 }
 
 /**
@@ -2971,80 +2852,20 @@ export class DynamicWorkflow extends WorkflowEntrypoint<
       graphHash: entryTrace.graphHash,
       extra: {
         instanceId: entryTrace.instanceId,
-        pooledBootstrap: entryTrace.pooledBootstrap,
       },
     });
-    let dispatchedEvent = event;
-    if (isPooledWorkflowBootstrapPayload(workflowEvent.payload)) {
-      const pooledPayload = workflowEvent.payload;
-      const waitingStep = step as {
-        waitForEvent<T>(
-          name: string,
-          options: { type: string; timeout?: string | number },
-        ): Promise<{ payload: Readonly<T>; timestamp: Date; type: string }>;
-      };
-      const waitStartedAt = Date.now();
-      const startEventPromise = waitingStep.waitForEvent<DispatcherEnvelope>(
-        'wait for pooled play start',
-        { type: WORKFLOW_POOL_START_EVENT_TYPE, timeout: '10 minutes' },
-      );
-      await markWorkflowPoolIdReady(this.env, pooledPayload.poolId).catch(
-        (error) => {
-          console.warn('[coordinator.workflow_pool] ready signal failed', {
-            poolId: pooledPayload.poolId,
-            message: error instanceof Error ? error.message : String(error),
-          });
-        },
-      );
-      const startEvent = await startEventPromise;
-      dispatchedEvent = {
-        payload: startEvent.payload,
-        timestamp: startEvent.timestamp,
-        instanceId: workflowEvent.instanceId ?? pooledPayload.poolId,
-      };
-      const dispatchedTrace = readWorkflowTraceContext(dispatchedEvent);
-      const mapped = await mapRunToWorkflowInstance({
-        env: this.env,
-        runId: dispatchedTrace.runId,
-        instanceId: pooledPayload.poolId,
-        started: true,
-      }).catch((error) => {
-        console.warn('[coordinator.workflow_pool] start ack failed', {
-          poolId: pooledPayload.poolId,
-          runId: dispatchedTrace.runId,
-          message: error instanceof Error ? error.message : String(error),
-        });
-        return false;
-      });
-      if (!mapped) {
-        trace({
-          runId: dispatchedTrace.runId,
-          phase: 'coordinator.workflow_pool_start_blocked',
-          ms: 0,
-          graphHash: dispatchedTrace.graphHash,
-          extra: {
-            instanceId: pooledPayload.poolId,
-            eventType: startEvent.type,
-          },
-        });
-        return { ok: false, blocked: true, runId: dispatchedTrace.runId };
-      }
-      const eventDeliveryMs = Math.max(
-        0,
-        Date.now() - startEvent.timestamp.getTime(),
-      );
+    if (entryTrace.submittedAt !== null) {
       trace({
-        runId: dispatchedTrace.runId,
-        phase: 'coordinator.workflow_pool_start_event',
-        ms: eventDeliveryMs,
-        graphHash: dispatchedTrace.graphHash,
+        runId: entryTrace.runId,
+        phase: 'coordinator.workflow_start_gap',
+        ms: Math.max(0, Date.now() - entryTrace.submittedAt),
+        graphHash: entryTrace.graphHash,
         extra: {
-          instanceId: dispatchedTrace.instanceId,
-          eventType: startEvent.type,
-          poolWaitAgeMs: Date.now() - waitStartedAt,
+          instanceId: entryTrace.instanceId,
         },
       });
     }
+    let dispatchedEvent = event;
     dispatchedEvent = await hydrateWorkflowDbSessions({
       env: this.env,
       event: dispatchedEvent,
@@ -3058,7 +2879,6 @@ export class DynamicWorkflow extends WorkflowEntrypoint<
       graphHash: dispatchTrace.graphHash,
       extra: {
         instanceId: dispatchTrace.instanceId,
-        pooledBootstrap: dispatchTrace.pooledBootstrap,
       },
     });
 
@@ -3212,9 +3032,6 @@ const coordinatorEntrypoint = {
   ): Promise<Response> {
     const url = new URL(request.url);
     if (url.pathname === '/health') {
-      if (workflowPoolEnabled()) {
-        ctx?.waitUntil(refillWorkflowPool(env).catch(() => undefined));
-      }
       return new Response('ok', { status: 200 });
     }
     if (url.pathname === '/warmup/submit') {
@@ -3250,100 +3067,6 @@ const coordinatorEntrypoint = {
       if (authError) return authError;
       return await handleStagedFilePut(request, env);
     }
-    if (url.pathname === '/workflow-pool/refill') {
-      const internalAuthError = authorizeCoordinatorControlRequest({
-        request,
-        env,
-      });
-      if (internalAuthError) return internalAuthError;
-      const warmupToken = env.VERCEL_PROTECTION_BYPASS_TOKEN?.trim();
-      if (
-        warmupToken &&
-        request.headers.get('x-vercel-protection-bypass') !== warmupToken
-      ) {
-        return new Response('unauthorized', { status: 401 });
-      }
-      const startedAt = Date.now();
-      const minAvailableRaw = Number(
-        url.searchParams.get('minAvailable') ?? '',
-      );
-      const waitTimeoutMsRaw = Number(
-        url.searchParams.get('waitTimeoutMs') ?? '',
-      );
-      const result = await refillWorkflowPool(env, {
-        waitReady: url.searchParams.get('waitReady') === '1',
-        minAvailable:
-          Number.isFinite(minAvailableRaw) && minAvailableRaw > 0
-            ? minAvailableRaw
-            : undefined,
-        waitTimeoutMs:
-          Number.isFinite(waitTimeoutMsRaw) && waitTimeoutMsRaw > 0
-            ? waitTimeoutMsRaw
-            : undefined,
-      });
-      return Response.json({
-        ok: true,
-        ...result,
-        ms: Date.now() - startedAt,
-      });
-    }
-    if (url.pathname === '/workflow-pool/clear') {
-      const internalAuthError = authorizeCoordinatorControlRequest({
-        request,
-        env,
-      });
-      if (internalAuthError) return internalAuthError;
-      const warmupToken = env.VERCEL_PROTECTION_BYPASS_TOKEN?.trim();
-      if (
-        warmupToken &&
-        request.headers.get('x-vercel-protection-bypass') !== warmupToken
-      ) {
-        return new Response('unauthorized', { status: 401 });
-      }
-      const startedAt = Date.now();
-      const deleted = await clearWorkflowPool(env);
-      return Response.json({
-        ok: true,
-        deleted,
-        ms: Date.now() - startedAt,
-      });
-    }
-    if (url.pathname === '/workflow-pool/debug') {
-      const internalAuthError = authorizeCoordinatorControlRequest({
-        request,
-        env,
-      });
-      if (internalAuthError) return internalAuthError;
-      const entries = await listWorkflowPoolEntries(env);
-      const detailed = [];
-      for (const entry of entries) {
-        const instance = await getWorkflowPoolInstance(env, entry.id);
-        if (!instance) {
-          detailed.push({
-            ...entry,
-            status: 'missing',
-            mappedStatus: 'failed',
-          });
-          continue;
-        }
-        try {
-          const status = await instance.status().catch(() => null);
-          detailed.push({
-            ...entry,
-            status: workflowStatusName(status),
-            mappedStatus: status ? mapWorkflowStatus(status) : 'running',
-          });
-        } finally {
-          disposeRpcStub(instance);
-        }
-      }
-      return Response.json({
-        ok: true,
-        enabled: workflowPoolEnabled(),
-        entries: detailed,
-      });
-    }
-
     // Workflow routes: /workflow/{runId}/{action}
     const wfMatch = url.pathname.match(/^\/workflow\/([^/]+)(?:\/(.+))?$/);
     if (wfMatch) {
@@ -3391,12 +3114,9 @@ const coordinatorEntrypoint = {
   },
   async scheduled(
     _controller: unknown,
-    env: CoordinatorEnv,
-    ctx?: ExecutionContext,
-  ): Promise<void> {
-    if (!workflowPoolEnabled()) return;
-    ctx?.waitUntil(refillWorkflowPool(env).catch(() => undefined));
-  },
+    _env: CoordinatorEnv,
+    _ctx?: ExecutionContext,
+  ): Promise<void> {},
 };
 
 export default coordinatorEntrypoint;
@@ -3601,69 +3321,101 @@ async function handleWorkflowRoute(input: {
         });
       input.ctx?.waitUntil(prewarmPromise);
     }
-    const workflowParams = await externalizeWorkflowDbSessions({
-      env,
+    const dbSessionExternalization = externalizedWorkflowDbSessionParams({
       params,
-      recordSubmitTiming,
-    });
-    await persistWorkflowRetryState({
-      env,
-      runId: submittedRunId,
-      params: workflowParams,
     });
-    let instance: WorkflowInstance | null = null;
+    const workflowParams = dbSessionExternalization.params;
     try {
-      const statusEventStartedAt = Date.now();
-      await appendCoordinatorRunEvent(env, {
+      const retryStateStartedAt = Date.now();
+      const launchState = await persistWorkflowLaunchState({
+        env,
         runId: submittedRunId,
-        type: 'status',
-        status: 'running',
-        ts: Date.now(),
+        params: workflowParams,
+        sessions: dbSessionExternalization.sessions,
+      });
+      const persistedAt = Date.now();
+      if (dbSessionExternalization.sessions.length > 0) {
+        recordSubmitTiming({
+          phase: 'coordinator.workflow_db_sessions_externalized',
+          ms: persistedAt - retryStateStartedAt,
+          graphHash: params.graphHash ?? null,
+          extra: {
+            sessions:
+              launchState.sessionCount ??
+              dbSessionExternalization.sessions.length,
+            expiresAt:
+              launchState.dbSessionsExpiresAt ??
+              dbSessionExternalization.ref?.expiresAt,
+            combinedLaunchState: true,
+          },
+        });
+      }
+      recordSubmitTiming({
+        phase: 'coordinator.retry_state_persistence',
+        ms: persistedAt - retryStateStartedAt,
+        graphHash: params.graphHash ?? null,
+        extra: {
+          combinedLaunchState: dbSessionExternalization.sessions.length > 0,
+        },
+      });
+    } catch (error) {
+      const errorMessage =
+        error instanceof Error ? error.message : String(error);
+      console.error('[coordinator] workflow retry state persistence failed', {
+        code: 'WORKFLOW_RETRY_STATE_PERSISTENCE_FAILED',
+        runId: submittedRunId,
+        error: errorMessage,
       });
       recordSubmitTiming({
-        phase: 'coordinator.submit_status_event',
-        ms: Date.now() - statusEventStartedAt,
+        phase: 'coordinator.retry_state_persistence',
+        ms: 0,
         graphHash: params.graphHash ?? null,
+        extra: {
+          status: 'failed',
+          error: errorMessage,
+        },
+      });
+      return workflowRetryStatePersistenceErrorResponse({
+        runId: submittedRunId,
+        error,
       });
+    }
+    workflowParams.submittedAt = Date.now();
+    let instance: WorkflowInstance | null = null;
+    try {
       const dispatchStartedAt = Date.now();
-      const poolAttemptStartedAt = Date.now();
-      instance = await submitViaPooledWorkflow({
+      const createStartedAt = Date.now();
+      instance = await createDynamicWorkflowInstance({
         env,
+        id: defaultInstanceId,
         params: workflowParams,
-        recordSubmitTiming,
       });
+      const workflowCreatedAt = Date.now();
       recordSubmitTiming({
-        phase: 'coordinator.workflow_pool_attempt',
-        ms: Date.now() - poolAttemptStartedAt,
+        phase: 'coordinator.workflow_create',
+        ms: workflowCreatedAt - createStartedAt,
         graphHash: params.graphHash ?? null,
-        extra: {
-          usedPool: Boolean(instance),
-          enabled: workflowPoolEnabled(),
-        },
+        extra: { instanceId: instance.id },
       });
-      if (!instance) {
-        const createStartedAt = Date.now();
-        instance = await createDynamicWorkflowInstance({
-          env,
-          id: defaultInstanceId,
-          params: workflowParams,
-        });
-        recordSubmitTiming({
-          phase: 'coordinator.workflow_create',
-          ms: Date.now() - createStartedAt,
-          graphHash: params.graphHash ?? null,
-          extra: { instanceId: instance.id },
+      const instanceIdRecord = recordWorkflowInstanceId({
+        env,
+        runId: submittedRunId,
+        instanceId: instance.id,
+      }).catch((error) => {
+        console.warn('[coordinator] workflow instance id record failed', {
+          runId: submittedRunId,
+          instanceId: instance?.id ?? null,
+          error: error instanceof Error ? error.message : String(error),
         });
-      }
+      });
+      input.ctx?.waitUntil(instanceIdRecord);
       recordSubmitTiming({
         phase: 'coordinator.dispatch_workflow',
         ms: Date.now() - dispatchStartedAt,
         graphHash: params.graphHash ?? null,
         extra: {
-          startMode:
-            instance.id === defaultInstanceId
-              ? 'direct_workflow_create'
-              : 'pooled_workflow_start_event',
+          startMode: 'direct_workflow_create',
+          instanceIdRecord: 'waitUntil',
         },
       });
       const initialWaitMsRaw = Number(
@@ -3698,9 +3450,6 @@ async function handleWorkflowRoute(input: {
         ms: totalMs,
         graphHash: params.graphHash ?? null,
       });
-      if (workflowPoolEnabled() && instance.id === defaultInstanceId) {
-        input.ctx?.waitUntil(refillWorkflowPool(env).catch(() => undefined));
-      }
       return Response.json({
         runId,
         status: 'submitted',
@@ -3733,126 +3482,17 @@ async function handleWorkflowRoute(input: {
           { status: 400 },
         );
       }
-      const manifest = body.manifest as PlayRuntimeManifest | undefined;
-      const governance = body.internalRunPlay as
-        | PlayCallGovernanceSnapshot
-        | undefined;
-      const childPlayName =
-        typeof body.name === 'string' && body.name.trim()
-          ? body.name.trim()
-          : manifest?.playName?.trim();
-      if (
-        !manifest ||
-        !childPlayName ||
-        !manifest.artifactStorageKey ||
-        !manifest.artifactHash ||
-        !manifest.graphHash ||
-        !governance
-      ) {
-        return Response.json(
-          {
-            error: {
-              code: 'CHILD_MANIFEST_REQUIRED',
-              message:
-                'submit-child requires a trusted child manifest and lineage.',
-              phase: 'coordinator_child_submit',
-              parentRunId: runId,
-            },
-          },
-          { status: 400 },
-        );
-      }
-      const childRunId = buildChildRunId(childPlayName);
-      const orgId = typeof body.orgId === 'string' ? body.orgId : '';
-      if (!orgId) {
-        return Response.json(
-          {
-            error: {
-              code: 'CHILD_ORG_REQUIRED',
-              message: 'submit-child requires orgId from the parent runtime.',
-              phase: 'coordinator_child_submit',
-              parentRunId: runId,
-            },
-          },
-          { status: 400 },
-        );
-      }
-      const parentExecutorToken =
-        typeof body.parentExecutorToken === 'string'
-          ? body.parentExecutorToken.trim()
-          : '';
-      if (!parentExecutorToken) {
-        return Response.json(
-          {
-            error: {
-              code: 'PARENT_EXECUTOR_TOKEN_REQUIRED',
-              message:
-                'submit-child requires the parent executor token for origin-scoped child token minting.',
-              phase: 'coordinator_child_submit',
-              parentRunId: runId,
-            },
-          },
-          { status: 400 },
-        );
-      }
-      const baseUrl = resolveRuntimeBaseUrl(env, body);
-      const childToken = await mintChildWorkflowExecutorToken({
-        env,
-        baseUrl,
-        parentExecutorToken,
-        parentRunId: runId,
-        parentPlayName:
-          typeof body.parentPlayName === 'string' && body.parentPlayName.trim()
-            ? body.parentPlayName.trim()
-            : governance.parentPlayName,
-        childRunId,
-        childPlayName,
-        maxCreditsPerRun: manifest.maxCreditsPerRun ?? null,
-      });
-      const preloadedDbSessions = await preloadChildRuntimeDbSessions({
-        env,
-        baseUrl,
-        childExecutorToken: childToken,
+      const {
+        response: submitResponse,
+        responseText,
         childRunId,
         childPlayName,
-        manifest,
-        orgId,
-        userEmail: typeof body.userEmail === 'string' ? body.userEmail : '',
-      });
-      const params = buildChildWorkflowParams({
+      } = await submitChildWorkflowThroughCoordinator({
         env,
+        parentRunId: runId,
         body,
-        manifest,
-        governance,
-        childRunId,
-        childPlayName,
-        childToken,
-        orgId,
         coordinatorUrl: new URL(request.url).origin,
-        runtimeBackend: 'cf_workflows_dynamic_worker',
-        dynamicWorkerCode:
-          typeof manifest.bundledCode === 'string'
-            ? manifest.bundledCode
-            : null,
-        preloadedDbSessions:
-          preloadedDbSessions.length > 0 ? preloadedDbSessions : null,
-      });
-      const submitResponse = await handleWorkflowRoute({
-        runId: childRunId,
-        action: 'submit',
-        request: new Request(
-          `https://deepline.coordinator.internal/workflow/${encodeURIComponent(
-            childRunId,
-          )}/submit`,
-          {
-            method: 'POST',
-            headers: { 'content-type': 'application/json' },
-            body: JSON.stringify(params),
-          },
-        ),
-        env,
       });
-      const responseText = await submitResponse.text().catch(() => '');
       recordCoordinatorPerfTrace({
         runId,
         phase: 'coordinator.child_submit',
@@ -4004,7 +3644,8 @@ async function handleWorkflowRoute(input: {
       .get('instanceId')
       ?.trim();
     const instanceId =
-      requestedInstanceId && !isWorkflowMutatingAction(action)
+      requestedInstanceId &&
+      isWorkflowInstanceIdForRun(runId, requestedInstanceId)
         ? requestedInstanceId
         : await resolveWorkflowInstanceIdForRun(env, runId);
     instance = await env.PLAY_WORKFLOW.get(instanceId);
@@ -4064,6 +3705,20 @@ async function handleWorkflowRoute(input: {
           : eventKey
             ? `integration_event_${eventKey}`
             : 'integration_event';
+      if (body.signal === 'integration_event' && eventKey) {
+        await writeCoordinatorChildTerminalState({
+          env,
+          parentRunId: runId,
+          eventKey,
+          data: body.data ?? body,
+        }).catch((error: unknown) => {
+          console.warn('[coordinator] child terminal cache write failed', {
+            runId,
+            eventKey,
+            error: error instanceof Error ? error.message : String(error),
+          });
+        });
+      }
       await instance.sendEvent({
         type: workflowEventType(eventType),
         payload: body,
@@ -4200,6 +3855,16 @@ function workflowInstanceId(runId: string): string {
   return `run-${stableHash(runId)}`;
 }
 
+function isWorkflowInstanceIdForRun(
+  runId: string,
+  instanceId: string,
+): boolean {
+  const canonical = workflowInstanceId(runId);
+  return (
+    instanceId === canonical || instanceId.startsWith(`${canonical}-retry-`)
+  );
+}
+
 function stableHash(value: string): string {
   let hash = 2166136261;
   for (let index = 0; index < value.length; index += 1) {
@@ -4323,10 +3988,11 @@ function loadDynamicPlayWorkerSync(
         // miswired environments fail before user code starts.
         HARNESS: env.HARNESS,
         VERCEL_PROTECTION_BYPASS_TOKEN: env.VERCEL_PROTECTION_BYPASS_TOKEN,
-        // In-process runtime API bridge used by the play harness for status,
-        // tool execution, DB session, and artifact callbacks. This avoids a
-        // public fetch hop when Cloudflare exposes the RuntimeApi export.
-        ...makeRuntimeApiEnvBinding(),
+        // Runtime API bridge used by the play harness for status, tool
+        // execution, DB session, and artifact callbacks. This uses the
+        // long-lived HARNESS service binding, avoiding public callback HTTP
+        // without relying on dynamic-worker access to named exports.
+        ...makeRuntimeApiEnvBinding(env),
         // In-process coordinator control bridge used by ctx.runPlay and
         // parent terminal signals. This keeps scalar child plays inline with
         // the parent instead of round-tripping through nested Workflow waits.
@@ -4411,7 +4077,7 @@ async function loadDynamicPlayWorker(
         // HARNESS, and child workflow control uses the COORDINATOR binding.
         HARNESS: env.HARNESS,
         VERCEL_PROTECTION_BYPASS_TOKEN: env.VERCEL_PROTECTION_BYPASS_TOKEN,
-        ...makeRuntimeApiEnvBinding(),
+        ...makeRuntimeApiEnvBinding(env),
         ...makeCoordinatorControlBinding(),
       },
     };
@@ -4861,20 +4527,6 @@ async function handleCoordinatorWarmup(
     graphHash: params.graphHash,
     extra: { status: response.status, label },
   });
-  const poolRefillPromise = refillWorkflowPool(env, {
-    waitReady: true,
-    minAvailable: 1,
-  }).catch(() => ({
-    available: 0,
-    warming: 0,
-    target: 0,
-    created: 0,
-    promoted: 0,
-    removed: 0,
-    waitedMs: 0,
-    waitIterations: 0,
-  }));
-  ctx?.waitUntil(poolRefillPromise.then(() => undefined));
   let body: unknown = null;
   try {
     body = text ? JSON.parse(text) : null;
@@ -4897,54 +4549,26 @@ async function handleCoordinatorWarmup(
       status: response.status,
       body,
       terminalState,
-      workflowPool: await poolRefillPromise,
     },
     { status: responseStatus },
   );
 }
 
 /**
- * Returns a structured-cloneable `Fetcher` stub for the `RuntimeApi`
- * WorkerEntrypoint. The stub goes into the per-graphHash play Worker's
- * `env.RUNTIME_API`. When the harness calls `env.RUNTIME_API.fetch(req)`,
- * the request is RPC-dispatched into the `RuntimeApi.fetch` method on the
- * coordinator side, which path-allowlists it and forwards to
- * `DEEPLINE_API_BASE_URL` directly. Skips the public *.workers.dev → CF
- * edge → cloudflared → localhost chain that the harness's old
- * `fetch(req.baseUrl + path)` path traverses.
- *
- * Implemented as a WorkerEntrypoint (not a plain closure) because Cloudflare
- * Workflows serializes the dynamic Worker's env when persisting workflow
- * state, and closures containing captured locals aren't
- * structured-cloneable. WorkerEntrypoint stubs ARE cloneable — same trick
- * `makePlayAssetsBinding` already uses.
- *
- * Falls back transparently when Cloudflare does not expose module exports in
- * the current execution path: if the binding is omitted from `env`, the play
- * worker uses its existing `fetch(req.baseUrl + path)` transport.
+ * Returns a structured-cloneable runtime API binding for the per-graphHash
+ * play Worker's `env.RUNTIME_API`. We intentionally pass the long-lived
+ * HARNESS WorkerEntrypoint service binding instead of a plain closure: the
+ * dynamic Worker env is serialized by Cloudflare Workflows, and service
+ * bindings are cloneable while closures are not. The per-play runtime accepts
+ * this binding via `runtimeApiCall(...)`, so callbacks still stay on
+ * service bindings and never fall back to public HTTP.
  */
-let loggedMissingRuntimeApiExport = false;
 let loggedMissingCoordinatorControlExport = false;
 
-function makeRuntimeApiEnvBinding():
-  | { RUNTIME_API: { fetch(req: Request): Promise<Response> } }
-  | Record<string, never> {
-  const exports = workersExports as unknown as {
-    RuntimeApi?: (init: { props: undefined }) => {
-      fetch(req: Request): Promise<Response>;
-    };
-  };
-  const ctor = exports.RuntimeApi;
-  if (typeof ctor !== 'function') {
-    if (!loggedMissingRuntimeApiExport) {
-      loggedMissingRuntimeApiExport = true;
-      console.warn(
-        '[coordinator] RuntimeApi is not registered on cloudflare:workers exports; using public runtime API transport.',
-      );
-    }
-    return {};
-  }
-  return { RUNTIME_API: ctor({ props: undefined }) };
+function makeRuntimeApiEnvBinding(env: CoordinatorEnv): {
+  RUNTIME_API: CoordinatorEnv['HARNESS'];
+} {
+  return { RUNTIME_API: env.HARNESS };
 }
 
 function makeCoordinatorControlBinding():
@@ -4954,6 +4578,10 @@ function makeCoordinatorControlBinding():
           parentRunId: string,
           body: Record<string, unknown>,
         ): Promise<{ workflowId?: string; runId?: string; error?: unknown }>;
+        submitWorkflowChild(
+          parentRunId: string,
+          body: Record<string, unknown>,
+        ): Promise<{ workflowId?: string; runId?: string; error?: unknown }>;
         signal(
           runId: string,
           body: Record<string, unknown>,
@@ -4966,6 +4594,28 @@ function makeCoordinatorControlBinding():
           runId: string,
           event: CoordinatorRunEvent,
         ): Promise<void>;
+        readTerminalState(
+          runId: string,
+        ): Promise<CoordinatorTerminalState | null>;
+        readChildTerminalState(
+          parentRunId: string,
+          eventKey: string,
+          timeoutMs?: number,
+        ): Promise<CoordinatorChildTerminalState | null>;
+        rateAcquire(input: {
+          bucketId: string;
+          rules: Array<{
+            ruleId: string;
+            requestsPerWindow: number;
+            windowMs: number;
+            maxConcurrency: number | null;
+          }>;
+          requested: number;
+        }): Promise<{ granted: number; waitMs: number }>;
+        ratePenalize(input: {
+          bucketId: string;
+          cooldownMs: number;
+        }): Promise<void>;
       };
     }
   | Record<string, never> {
@@ -4975,6 +4625,10 @@ function makeCoordinatorControlBinding():
         parentRunId: string,
         body: Record<string, unknown>,
       ): Promise<{ workflowId?: string; runId?: string; error?: unknown }>;
+      submitWorkflowChild(
+        parentRunId: string,
+        body: Record<string, unknown>,
+      ): Promise<{ workflowId?: string; runId?: string; error?: unknown }>;
       signal(
         runId: string,
         body: Record<string, unknown>,
@@ -4984,6 +4638,28 @@ function makeCoordinatorControlBinding():
         payload: CoordinatorPerfTracePayload,
       ): Promise<void>;
       recordRunEvent(runId: string, event: CoordinatorRunEvent): Promise<void>;
+      readTerminalState(
+        runId: string,
+      ): Promise<CoordinatorTerminalState | null>;
+      readChildTerminalState(
+        parentRunId: string,
+        eventKey: string,
+        timeoutMs?: number,
+      ): Promise<CoordinatorChildTerminalState | null>;
+      rateAcquire(input: {
+        bucketId: string;
+        rules: Array<{
+          ruleId: string;
+          requestsPerWindow: number;
+          windowMs: number;
+          maxConcurrency: number | null;
+        }>;
+        requested: number;
+      }): Promise<{ granted: number; waitMs: number }>;
+      ratePenalize(input: {
+        bucketId: string;
+        cooldownMs: number;
+      }): Promise<void>;
     };
   };
   const ctor = exports.CoordinatorControl;