deepline 0.1.228 → 0.1.229

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

@@ -29,11 +29,7 @@ import {
   type WorkflowRunner,
 } from '@cloudflare/dynamic-workflows';
 import type { ExecutionPlan } from '../../../shared_libs/play-runtime/execution-plan';
-import { buildChildRunId as buildSharedChildRunId } from '../../../shared_libs/play-runtime/child-run-id';
-import type {
-  PlayCallGovernanceSnapshot,
-  PlayRunInputPayload,
-} from '../../../shared_libs/play-runtime/scheduler-backend';
+import type { PlayRunInputPayload } from '../../../shared_libs/play-runtime/scheduler-backend';
 import type { RuntimeTestPolicyOverrides } from '../../../shared_libs/play-runtime/test-runtime-seams';
 import { DYNAMIC_PLAY_WORKER_ARTIFACT_VERSION } from '../../../shared_libs/play-runtime/dynamic-worker-version';
 import {
@@ -45,10 +41,7 @@ import {
   encryptDbSessionPostgresUrl,
 } from '../../../shared_libs/play-runtime/db-session-crypto';
 import { planRuntimeDbSessionRequirements } from '../../../shared_libs/play-runtime/db-session-plan';
-import type {
-  PlayRuntimeManifest,
-  PlayRuntimeManifestMap,
-} from '../../../shared_libs/plays/compiler-manifest';
+import type { PlayRuntimeManifest } from '../../../shared_libs/plays/compiler-manifest';
 import {
   WORKSPACE_STORAGE_NOT_READY_CODE,
   WORKSPACE_STORAGE_NOT_READY_MESSAGE,
@@ -59,10 +52,6 @@ import {
   COORDINATOR_INTERNAL_TOKEN_HEADER,
   COORDINATOR_RUN_SCOPE_HEADER,
 } from '../../../shared_libs/play-runtime/coordinator-headers';
-import {
-  PLAY_RUNTIME_CONTRACT,
-  PLAY_RUNTIME_CONTRACT_HEADER,
-} from '../../../shared_libs/play-runtime/runtime-contract';
 import {
   PLAY_RUNTIME_API_COMPAT_PATH,
   PLAY_RUNTIME_TAIL_LOG_COMPAT_PATH,
@@ -173,8 +162,6 @@ export type PlayWorkflowParams = {
   }> | null;
   contractSnapshot?: unknown;
   executionPlan?: ExecutionPlan | null;
-  childPlayManifests?: PlayRuntimeManifestMap | null;
-  playCallGovernance?: PlayCallGovernanceSnapshot | null;
   forceToolRefresh?: boolean | null;
   preloadedDbSessions?: PreloadedRuntimeDbSession[] | null;
   preloadedDbSessionRef?: {
@@ -185,8 +172,6 @@ export type PlayWorkflowParams = {
   dynamicWorkerCode?: string | null;
   executorToken: string;
   baseUrl: string;
-  runtimeApiBaseUrl?: string | null;
-  callbackUrl?: string | null;
   integrationMode?: 'live' | 'eval_stub' | 'fixture' | null;
   orgId: string;
   userEmail: string;
@@ -201,27 +186,6 @@ export type PlayWorkflowParams = {
   submittedAt?: number | null;
 };
 
-type InlineChildSubmitResult =
-  | {
-      workflowId: string;
-      runId: string;
-      status: 'completed';
-      mode: 'inline_dynamic_worker';
-      output: unknown;
-      result: unknown;
-      logs: string[];
-      timings: CoordinatorTiming[];
-    }
-  | {
-      workflowId: string;
-      runId: string;
-      status: 'failed';
-      mode: 'inline_dynamic_worker';
-      error: { message: string; stack?: string | null };
-      logs: string[];
-      timings: CoordinatorTiming[];
-    };
-
 type CoordinatorTiming = {
   phase: string;
   ms: number;
@@ -262,12 +226,6 @@ type CoordinatorTerminalState = {
   completedAt?: number;
 };
 
-type CoordinatorChildTerminalState = {
-  eventKey: string;
-  data: unknown;
-  storedAt: number;
-};
-
 type CoordinatorRunEvent =
   | {
       seq?: number;
@@ -648,67 +606,6 @@ 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: coordinatorStorageRedactor.redact(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()
@@ -1484,47 +1381,6 @@ async function markWorkflowRuntimeFailure(input: {
   );
 }
 
-async function appendWorkflowChildCompletedRunEvent(input: {
-  env: CoordinatorEnv;
-  event: unknown;
-  result: unknown;
-}): Promise<boolean> {
-  const payload = readWorkflowPayload(input.event);
-  if (!payload || !isRecord(payload.playCallGovernance)) return false;
-  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 false;
-  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.completed',
-        runId,
-        source: 'worker',
-        occurredAt: Date.now(),
-        result: input.result,
-      } satisfies PlayRunLedgerEvent,
-    ],
-  });
-  const url = `${baseUrl.replace(/\/$/, '')}${PLAY_RUNTIME_API_COMPAT_PATH}`;
-  const response = await fetch(url, { method: 'POST', headers, body });
-  if (!response.ok) {
-    throw new Error(
-      `runtime API responded ${response.status}: ${(await response.text().catch(() => '')).slice(0, 400)}`,
-    );
-  }
-  return true;
-}
-
 type StoredPlayArtifactPayload = {
   artifact?: {
     bundledCode?: string;
@@ -1835,1460 +1691,95 @@ function workflowRetryInstanceId(runId: string, attempt: number): string {
 
 function normalizeWorkflowRunAttempt(value: unknown): number {
   return typeof value === 'number' && Number.isFinite(value)
-    ? Math.max(0, Math.floor(value))
-    : 0;
-}
-
-async function restartWorkflowAfterPlatformReset(input: {
-  env: CoordinatorEnv;
-  ctx?: ExecutionContext;
-  runId: string;
-  oldInstance: WorkflowInstance;
-  error: string;
-  status: InstanceStatus;
-}): Promise<{
-  retried: boolean;
-  result: Record<string, unknown> | null;
-}> {
-  const decision = decideWorkflowPlatformRetry({
-    workflowStatus: String(input.status.status ?? ''),
-    error: input.error,
-    retryAttempts: 0,
-  });
-  if (decision.action !== 'retry') {
-    return { retried: false, result: null };
-  }
-  const claim = await claimWorkflowPlatformRetry({
-    env: input.env,
-    runId: input.runId,
-  }).catch((error) => {
-    recordCoordinatorEvent(
-      'warn',
-      'coordinator.workflow_platform_retry.claim_failed',
-      '[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;
-  const retryParams = { ...claim.params, runAttempt: claim.attempts };
-  try {
-    retryInstance = await createDynamicWorkflowInstance({
-      env: input.env,
-      id: retryInstanceId,
-      params: workflowCreateParams(retryParams, {
-        params: retryParams,
-        paramsRef: claim.paramsRef,
-      }),
-      metadataParams: retryParams,
-    });
-    await recordWorkflowInstanceId({
-      env: input.env,
-      runId: input.runId,
-      instanceId: retryInstance.id,
-    });
-    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 markRegisteredChildRunFailed(input: {
-  env: CoordinatorEnv;
-  baseUrl: string;
-  childExecutorToken: string;
-  childRunId: string;
-  error: unknown;
-}): Promise<void> {
-  const message =
-    input.error instanceof Error ? input.error.message : String(input.error);
-  const response = await input.env.HARNESS.runtimeApiCall({
-    contract: PLAY_RUNTIME_CONTRACT,
-    executorToken: input.childExecutorToken,
-    baseUrl: input.baseUrl,
-    path: PLAY_RUNTIME_API_COMPAT_PATH,
-    headers: {
-      'x-deepline-request-id': crypto.randomUUID(),
-      [PLAY_RUNTIME_CONTRACT_HEADER]: String(PLAY_RUNTIME_CONTRACT),
-    },
-    timeoutMs: 15_000,
-    body: {
-      action: 'append_run_events',
-      playId: input.childRunId,
-      events: [
-        {
-          type: 'run.failed',
-          runId: input.childRunId,
-          source: 'coordinator',
-          occurredAt: Date.now(),
-          error: `Child workflow submit failed: ${message}`,
-        } satisfies PlayRunLedgerEvent,
-      ],
-    },
-  });
-  if (response.status < 200 || response.status >= 300) {
-    const text = response.body ?? '';
-    throw new Error(
-      `Inline child run failure mark failed ${response.status}: ${text.slice(0, 800)}`,
-    );
-  }
-}
-
-async function appendRegisteredChildRunTerminal(input: {
-  env: CoordinatorEnv;
-  baseUrl: string;
-  childExecutorToken: string;
-  childRunId: string;
-  status: 'completed' | 'failed';
-  result?: unknown;
-  error?: string | null;
-}): Promise<void> {
-  const event =
-    input.status === 'completed'
-      ? ({
-          type: 'run.completed',
-          runId: input.childRunId,
-          source: 'worker',
-          occurredAt: Date.now(),
-          ...(input.result !== undefined ? { result: input.result } : {}),
-        } satisfies PlayRunLedgerEvent)
-      : ({
-          type: 'run.failed',
-          runId: input.childRunId,
-          source: 'worker',
-          occurredAt: Date.now(),
-          error: input.error ?? 'Inline child Worker failed.',
-        } satisfies PlayRunLedgerEvent);
-  const response = await input.env.HARNESS.runtimeApiCall({
-    contract: PLAY_RUNTIME_CONTRACT,
-    executorToken: input.childExecutorToken,
-    baseUrl: input.baseUrl,
-    path: PLAY_RUNTIME_API_COMPAT_PATH,
-    headers: {
-      'x-deepline-request-id': crypto.randomUUID(),
-      [PLAY_RUNTIME_CONTRACT_HEADER]: String(PLAY_RUNTIME_CONTRACT),
-    },
-    timeoutMs: 15_000,
-    body: {
-      action: 'append_run_events',
-      playId: input.childRunId,
-      events: [event],
-    },
-  });
-  if (response.status < 200 || response.status >= 300) {
-    const text = response.body ?? '';
-    throw new Error(
-      `Inline child terminal append failed ${response.status}: ${text.slice(0, 800)}`,
-    );
-  }
-}
-
-type CoordinatorRuntimeApiTiming = {
-  phase: string;
-  ms: number;
-  bytes?: number;
-};
-
-async function callRuntimeApiFromCoordinator(input: {
-  env: CoordinatorEnv;
-  baseUrl: string;
-  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 requestId = crypto.randomUUID();
-  const action =
-    body && typeof body === 'object' && !Array.isArray(body)
-      ? String((body as { action?: unknown }).action ?? 'unknown')
-      : 'unknown';
-  const runId =
-    body && typeof body === 'object' && !Array.isArray(body)
-      ? String(
-          (body as { runId?: unknown; playId?: unknown }).runId ??
-            (body as { runId?: unknown; playId?: unknown }).playId ??
-            '',
-        ) || null
-      : null;
-  recordCoordinatorEvent(
-    'info',
-    'coordinator.runtime_api.breadcrumb',
-    '[coordinator.runtime_api.breadcrumb]',
-    {
-      phase: 'request',
-      action,
-      runId,
-      requestId,
-      baseOrigin: safeOrigin(input.baseUrl),
-    },
-  );
-  const response = await input.env.HARNESS.runtimeApiCall({
-    contract: PLAY_RUNTIME_CONTRACT,
-    executorToken: input.executorToken,
-    baseUrl: input.baseUrl,
-    path: PLAY_RUNTIME_API_COMPAT_PATH,
-    body,
-    headers: {
-      'x-deepline-request-id': requestId,
-      [PLAY_RUNTIME_CONTRACT_HEADER]: String(PLAY_RUNTIME_CONTRACT),
-    },
-  });
-  recordTiming('coordinator.runtime_api.fetch', fetchStartedAt);
-  recordCoordinatorEvent(
-    'info',
-    'coordinator.runtime_api.breadcrumb',
-    '[coordinator.runtime_api.breadcrumb]',
-    {
-      phase: 'response',
-      action,
-      runId,
-      requestId,
-      status: response.status,
-      ms: Date.now() - fetchStartedAt,
-      baseOrigin: safeOrigin(input.baseUrl),
-    },
-  );
-
-  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 prepareInlineChildRunWithRuntime(input: {
-  env: CoordinatorEnv;
-  baseUrl: string;
-  parentExecutorToken: string;
-  parentRunId: string;
-  parentPlayName: string;
-  childRunId: string;
-  childPlayName: string;
-  manifest: PlayRuntimeManifest;
-  governance: PlayCallGovernanceSnapshot;
-  userEmail: string;
-  runtimeBackend?: string;
-  schedulerBackend?: string;
-  executionProfile?: string;
-}): Promise<{
-  childToken: string;
-  preloadedDbSessions: PreloadedRuntimeDbSession[];
-  prepareTimings: unknown[];
-  transportTimings: unknown[];
-}> {
-  const response = await callRuntimeApiFromCoordinator({
-    env: input.env,
-    baseUrl: input.baseUrl,
-    executorToken: input.parentExecutorToken,
-    body: {
-      action: 'prepare_inline_child_run',
-      parentRunId: input.parentRunId,
-      rootRunId: input.governance.rootRunId,
-      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: input.runtimeBackend ?? 'workers_edge',
-      schedulerBackend: input.schedulerBackend ?? 'inline_child',
-      executionProfile: input.executionProfile ?? 'workers_edge',
-      ...(typeof input.manifest.maxCreditsPerRun === 'number'
-        ? { maxCreditsPerRun: input.manifest.maxCreditsPerRun }
-        : {}),
-      staticPipeline: input.manifest.staticPipeline ?? null,
-      source: 'published',
-      userEmail: input.userEmail,
-    },
-  });
-  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(input: {
-  playName: string;
-  parentRunId: string;
-  body: Record<string, unknown>;
-}): string {
-  const { playName, parentRunId, body } = input;
-  const governance = isRecord(body.internalRunPlay)
-    ? body.internalRunPlay
-    : null;
-  // Adapt the coordinator's on-the-wire child-submit body to the shared
-  // derivation. Output stays byte-identical to the previous inline
-  // implementation (same fields → same digest → same run id), so child-submit
-  // idempotency is preserved. See shared_libs/play-runtime/child-run-id.ts.
-  return buildSharedChildRunId({
-    childPlayName: playName,
-    parentRunId,
-    explicitIdempotencyKey:
-      typeof body.childIdempotencyKey === 'string'
-        ? body.childIdempotencyKey
-        : null,
-    parentPlayName:
-      typeof governance?.parentPlayName === 'string'
-        ? governance.parentPlayName
-        : null,
-    key: typeof governance?.key === 'string' ? governance.key : null,
-    input: isRecord(body.input) || Array.isArray(body.input) ? body.input : {},
-    graphHash: isRecord(body.manifest)
-      ? typeof body.manifest.graphHash === 'string'
-        ? body.manifest.graphHash
-        : null
-      : null,
-  });
-}
-
-function normalizeRuntimeBaseUrl(value: unknown): string | null {
-  if (typeof value !== 'string') return null;
-  const trimmed = value.trim();
-  if (!trimmed) return null;
-  let parsed: URL;
-  try {
-    parsed = new URL(trimmed);
-  } catch {
-    return null;
-  }
-  if (
-    (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') ||
-    parsed.username ||
-    parsed.password ||
-    parsed.search ||
-    parsed.hash ||
-    (parsed.pathname !== '/' && parsed.pathname !== '')
-  ) {
-    return null;
-  }
-  return parsed.toString().replace(/\/$/, '');
-}
-
-const DEEPLINE_PRODUCTION_APP_HOST = 'code.deepline.com';
-const DEEPLINE_VERCEL_DEPLOYMENT_HOST_RE =
-  /^deepline-api(?:-[a-z0-9-]+)?-aero-team-0f650658\.vercel\.app$/i;
-const DEEPLINE_VERCEL_PROJECT_HOST_RE =
-  /^deepline-[a-z0-9]+-aero-team-0f650658\.vercel\.app$/i;
-const DEEPLINE_WORKERS_DEV_SUBDOMAINS = new Set(['chirag-d94']);
-
-function isDeeplineCoordinatorWorkerHost(hostname: string): boolean {
-  const labels = hostname.toLowerCase().split('.');
-  return (
-    labels.length === 4 &&
-    labels[0]?.startsWith('deepline-play-coordinator-') &&
-    labels[2] === 'workers' &&
-    labels[3] === 'dev' &&
-    DEEPLINE_WORKERS_DEV_SUBDOMAINS.has(labels[1] ?? '')
-  );
-}
-
-function shouldCanonicalizeRuntimeApiBaseUrl(input: {
-  configuredBaseUrl: URL;
-  overrideBaseUrl: URL;
-}): boolean {
-  if (input.overrideBaseUrl.host === input.configuredBaseUrl.host) {
-    return false;
-  }
-  const configuredHostname = input.configuredBaseUrl.hostname.toLowerCase();
-  const overrideHostname = input.overrideBaseUrl.hostname.toLowerCase();
-  if (isDeeplineCoordinatorWorkerHost(overrideHostname)) {
-    return true;
-  }
-  const overrideIsDeeplineVercelHost =
-    DEEPLINE_VERCEL_DEPLOYMENT_HOST_RE.test(overrideHostname) ||
-    DEEPLINE_VERCEL_PROJECT_HOST_RE.test(overrideHostname);
-  if (!overrideIsDeeplineVercelHost) {
-    return false;
-  }
-  const configuredIsDeeplineVercelHost =
-    DEEPLINE_VERCEL_DEPLOYMENT_HOST_RE.test(configuredHostname) ||
-    DEEPLINE_VERCEL_PROJECT_HOST_RE.test(configuredHostname);
-  return (
-    configuredHostname === DEEPLINE_PRODUCTION_APP_HOST ||
-    !configuredIsDeeplineVercelHost
-  );
-}
-
-function resolveRuntimeApiBaseUrl(
-  env: CoordinatorEnv,
-  body: Record<string, unknown>,
-): string {
-  const configuredBaseUrl =
-    normalizeRuntimeBaseUrl(env.DEEPLINE_API_BASE_URL) ??
-    env.DEEPLINE_API_BASE_URL.replace(/\/$/, '');
-  const overrideBaseUrl =
-    normalizeRuntimeBaseUrl(body.runtimeApiBaseUrl) ??
-    normalizeRuntimeBaseUrl(body.baseUrl);
-  if (!overrideBaseUrl) {
-    return configuredBaseUrl;
-  }
-  if (
-    shouldCanonicalizeRuntimeApiBaseUrl({
-      configuredBaseUrl: new URL(configuredBaseUrl),
-      overrideBaseUrl: new URL(overrideBaseUrl),
-    })
-  ) {
-    return configuredBaseUrl;
-  }
-  return overrideBaseUrl;
-}
-
-function resolveWorkflowCallbackBaseUrl(
-  env: CoordinatorEnv,
-  body: Record<string, unknown>,
-): string {
-  return (
-    normalizeRuntimeBaseUrl(body.callbackBaseUrl) ??
-    normalizeRuntimeBaseUrl(body.callbackUrl) ??
-    normalizeRuntimeBaseUrl(body.baseUrl) ??
-    env.DEEPLINE_API_BASE_URL.replace(/\/$/, '')
-  );
-}
-
-function validateChildSubmitBody(input: {
-  parentRunId: string;
-  body: Record<string, unknown>;
-}):
-  | {
-      ok: true;
-      manifest: PlayRuntimeManifest;
-      governance: PlayCallGovernanceSnapshot;
-      childPlayName: string;
-      orgId: string;
-      parentExecutorToken: string;
-    }
-  | { ok: false; status: number; error: Record<string, unknown> } {
-  const { parentRunId, body } = input;
-  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 {
-      ok: false,
-      status: 400,
-      error: {
-        code: 'CHILD_MANIFEST_REQUIRED',
-        message: 'submit-child requires a trusted child manifest and lineage.',
-        phase: 'coordinator_child_submit',
-        parentRunId,
-      },
-    };
-  }
-  const orgId = typeof body.orgId === 'string' ? body.orgId : '';
-  if (!orgId) {
-    return {
-      ok: false,
-      status: 400,
-      error: {
-        code: 'CHILD_ORG_REQUIRED',
-        message: 'submit-child requires orgId from the parent runtime.',
-        phase: 'coordinator_child_submit',
-        parentRunId,
-      },
-    };
-  }
-  const parentExecutorToken =
-    typeof body.parentExecutorToken === 'string'
-      ? body.parentExecutorToken.trim()
-      : '';
-  if (!parentExecutorToken) {
-    return {
-      ok: false,
-      status: 400,
-      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,
-      },
-    };
-  }
-  return {
-    ok: true,
-    manifest,
-    governance,
-    childPlayName,
-    orgId,
-    parentExecutorToken,
-  };
-}
-
-function buildChildWorkflowParams(input: {
-  env: CoordinatorEnv;
-  body: Record<string, unknown>;
-  manifest: PlayRuntimeManifest;
-  governance: PlayCallGovernanceSnapshot;
-  childRunId: string;
-  childPlayName: string;
-  childToken: string;
-  orgId: string;
-  coordinatorUrl: string | null;
-  runtimeBackend: string;
-  dynamicWorkerCode: string | null;
-  preloadedDbSessions: PreloadedRuntimeDbSession[] | null;
-}): PlayWorkflowParams {
-  const {
-    env,
-    body,
-    manifest,
-    governance,
-    childRunId,
-    childPlayName,
-    childToken,
-    orgId,
-    coordinatorUrl,
-    runtimeBackend,
-    dynamicWorkerCode,
-    preloadedDbSessions,
-  } = input;
-  const baseUrl = resolveRuntimeApiBaseUrl(env, body);
-  const callbackUrl = resolveWorkflowCallbackBaseUrl(env, body);
-  return {
-    runId: childRunId,
-    playId: childRunId,
-    playName: childPlayName,
-    artifactStorageKey: manifest.artifactStorageKey,
-    artifactHash: manifest.artifactHash,
-    graphHash: manifest.graphHash,
-    input: isRecord(body.input) || Array.isArray(body.input) ? body.input : {},
-    contractSnapshot: {
-      source: 'published',
-      revisionVersion: null,
-      staticPipeline: manifest.staticPipeline,
-      billingLimit:
-        typeof manifest.maxCreditsPerRun === 'number'
-          ? { maxCreditsPerRun: manifest.maxCreditsPerRun }
-          : null,
-      sourceCode: manifest.sourceCode ?? '',
-      artifactMetadata: {
-        storageKey: manifest.artifactStorageKey,
-        artifactHash: manifest.artifactHash,
-        graphHash: manifest.graphHash,
-      },
-      codeFormat: 'cjs_module',
-      compatibility: {
-        apiVersion: 2,
-        runtimeBackend: 'workers_edge',
-      },
-    },
-    executionPlan: null,
-    childPlayManifests: isRecord(body.childPlayManifests)
-      ? (body.childPlayManifests as PlayRuntimeManifestMap)
-      : null,
-    playCallGovernance: governance,
-    preloadedDbSessions,
-    dynamicWorkerCode,
-    executorToken: childToken,
-    baseUrl: callbackUrl,
-    runtimeApiBaseUrl: baseUrl,
-    callbackUrl,
-    integrationMode: normalizeIntegrationMode(body.integrationMode),
-    force: body.force === true || body.forceToolRefresh === true,
-    forceToolRefresh: body.forceToolRefresh === true,
-    orgId,
-    userEmail: typeof body.userEmail === 'string' ? body.userEmail : '',
-    userId: typeof body.userId === 'string' ? body.userId : null,
-    runtimeBackend,
-    dedupBackend: 'in_memory',
-    coordinatorUrl,
-    coordinatorInternalToken: env.DEEPLINE_INTERNAL_TOKEN?.trim() || null,
-  };
-}
-
-function runRequestFromPlayWorkflowParams(
-  params: PlayWorkflowParams,
-): Record<string, unknown> {
-  const inputFileName = String(
-    params.inputFile?.name ??
-      params.inputFile?.fileName ??
-      params.inputFile?.logicalPath ??
-      params.inputFile?.path ??
-      '',
-  );
-  const inputStorageKey =
-    params.inputFile?.r2Key ?? params.inputFile?.storageKey ?? null;
-  return {
-    runId: params.runId,
-    callbackUrl: params.callbackUrl ?? params.baseUrl,
-    executorToken: params.executorToken,
-    baseUrl: params.runtimeApiBaseUrl ?? params.baseUrl,
-    integrationMode: normalizeIntegrationMode(params.integrationMode),
-    orgId: params.orgId,
-    playName: params.playName,
-    graphHash: params.graphHash,
-    userEmail: params.userEmail,
-    runtimeInput: params.input,
-    runAttempt: normalizeWorkflowRunAttempt(params.runAttempt),
-    inlineCsv: params.inlineCsv ?? null,
-    inputFiles:
-      inputStorageKey && inputFileName
-        ? {
-            [inputFileName]: {
-              logicalPath:
-                params.inputFile?.logicalPath ??
-                params.inputFile?.path ??
-                inputFileName,
-              fileName: params.inputFile?.fileName ?? inputFileName,
-              storageKey: inputStorageKey,
-              contentType: params.inputFile?.contentType ?? null,
-              bytes:
-                typeof params.inputFile?.bytes === 'number'
-                  ? params.inputFile.bytes
-                  : null,
-            },
-          }
-        : null,
-    packagedFiles: params.packagedFiles ?? null,
-    partitionRange: null,
-    dedupBackend: params.dedupBackend,
-    resumeFromCheckpointR2Key: null,
-    contractSnapshot: params.contractSnapshot ?? null,
-    executionPlan: params.executionPlan ?? null,
-    childPlayManifests: params.childPlayManifests ?? null,
-    playCallGovernance: params.playCallGovernance ?? null,
-    force: params.force === true || params.forceToolRefresh === true,
-    forceToolRefresh: params.forceToolRefresh === true,
-    preloadedDbSessions: params.preloadedDbSessions ?? null,
-    runtimeTestFaultHeader: params.runtimeTestFaultHeader ?? null,
-    testPolicyOverrides: params.testPolicyOverrides ?? null,
-    coordinatorUrl: params.coordinatorUrl ?? null,
-    coordinatorInternalToken: params.coordinatorInternalToken ?? null,
-    totalRows: params.totalRows,
-  };
-}
-
-async function readLegacyRunStream(response: Response): Promise<{
-  result: unknown;
-  outputRows: number | null;
-  logs: string[];
-  error: { message: string; stack: string | null } | null;
-}> {
-  if (!response.body) {
-    throw new Error('Legacy child Worker returned an empty stream.');
-  }
-  const decoder = new TextDecoder();
-  const reader = response.body.getReader();
-  const logs: string[] = [];
-  let result: unknown = null;
-  let outputRows: number | null = null;
-  let error: { message: string; stack: string | null } | null = null;
-  let buffered = '';
-
-  const consumeLine = (line: string): void => {
-    const trimmed = line.trim();
-    if (!trimmed) {
-      return;
-    }
-    let event: unknown;
-    try {
-      event = JSON.parse(trimmed);
-    } catch {
-      logs.push(trimmed);
-      return;
-    }
-    if (!event || typeof event !== 'object') {
-      return;
-    }
-    const record = event as Record<string, unknown>;
-    if (record.type === 'log' && typeof record.message === 'string') {
-      logs.push(record.message);
-      return;
-    }
-    if (record.type === 'result') {
-      result = record.result;
-      outputRows =
-        typeof record.outputRows === 'number' ? record.outputRows : null;
-      return;
-    }
-    if (record.type === 'error') {
-      error = {
-        message:
-          typeof record.message === 'string'
-            ? record.message
-            : 'Legacy child Worker failed.',
-        stack: typeof record.stack === 'string' ? record.stack : null,
-      };
-    }
-  };
-
-  for (;;) {
-    const { value, done } = await reader.read();
-    if (value) {
-      buffered += decoder.decode(value, { stream: !done });
-      const lines = buffered.split('\n');
-      buffered = lines.pop() ?? '';
-      for (const line of lines) {
-        consumeLine(line);
-      }
-    }
-    if (done) {
-      buffered += decoder.decode();
-      consumeLine(buffered);
-      break;
-    }
-  }
-
-  return { result, outputRows, logs, error };
-}
-
-async function executeChildInline(input: {
-  env: CoordinatorEnv;
-  parentRunId: string;
-  body: Record<string, unknown>;
-}): Promise<InlineChildSubmitResult> {
-  const startedAt = Date.now();
-  const validated = validateChildSubmitBody(input);
-  if (!validated.ok) {
-    throw new Error(String(validated.error.message ?? 'Invalid child submit.'));
-  }
-  const { manifest, governance, childPlayName, orgId, parentExecutorToken } =
-    validated;
-  const childRunId = buildChildRunId({
-    playName: childPlayName,
-    parentRunId: input.parentRunId,
-    body: input.body,
-  });
-  const timings: CoordinatorTiming[] = [];
-  const trace = (
-    phase: string,
-    phaseStartedAt: number,
-    extra?: Record<string, unknown>,
-  ): void => {
-    const timing: CoordinatorTiming = {
-      phase,
-      ms: Date.now() - phaseStartedAt,
-      graphHash: manifest.graphHash,
-      ...(extra ? { extra } : {}),
-    };
-    timings.push(timing);
-    recordCoordinatorPerfTrace({
-      runId: childRunId,
-      phase,
-      ms: timing.ms,
-      graphHash: manifest.graphHash,
-      extra: {
-        parentRunId: input.parentRunId,
-        mode: 'inline_dynamic_worker',
-        ...(extra ?? {}),
-      },
-    });
-  };
-  recordCoordinatorPerfTrace({
-    runId: childRunId,
-    phase: 'coordinator.inline_child_boundary',
-    ms: 0,
-    graphHash: manifest.graphHash,
-    extra: {
-      parentRunId: input.parentRunId,
-      childPlayName,
-      action: 'start',
-      mode: 'inline_dynamic_worker',
-    },
-  });
-
-  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);
-
-  const prepareStartedAt = Date.now();
-  const parentPlayName =
-    typeof input.body.parentPlayName === 'string' &&
-    input.body.parentPlayName.trim()
-      ? input.body.parentPlayName.trim()
-      : governance.parentPlayName;
-  const baseUrl = resolveRuntimeApiBaseUrl(input.env, input.body);
-  const { childToken, preloadedDbSessions, prepareTimings, transportTimings } =
-    await prepareInlineChildRunWithRuntime({
-      env: input.env,
-      baseUrl,
-      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({
-    env: input.env,
-    body: input.body,
-    manifest,
-    governance,
-    childRunId,
-    childPlayName,
-    childToken,
-    orgId,
-    coordinatorUrl: null,
-    runtimeBackend: 'cf_workflows_dynamic_worker_inline_child',
-    dynamicWorkerCode: null,
-    preloadedDbSessions:
-      preloadedDbSessions.length > 0 ? preloadedDbSessions : null,
-  });
-
-  let entrypoint: ReturnType<Awaited<typeof stub>['getEntrypoint']> | null =
-    null;
-  let response: Response | null = null;
-  try {
-    const awaitedStub = await stub;
-    const entrypointStartedAt = Date.now();
-    entrypoint = awaitedStub.getEntrypoint();
-    trace('coordinator.inline_child_get_entrypoint', entrypointStartedAt);
-    const fetchStartedAt = Date.now();
-    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: workerResponse.status,
-      endpoint: '/run-inline',
-    });
-    let usedLegacyRunStream = false;
-    if (workerResponse.status === 404) {
-      disposeRpcStub(workerResponse);
-      const legacyFetchStartedAt = Date.now();
-      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: workerResponse.status,
-        endpoint: '/run',
-        compatibility: 'legacy_stream',
-      });
-    }
-    if (!workerResponse.ok) {
-      const text = await workerResponse.text().catch(() => '');
-      throw new Error(
-        `Inline child Worker failed ${workerResponse.status}: ${text.slice(0, 800)}`,
-      );
-    }
-    const responseStartedAt = Date.now();
-    const parsed: InlineWorkerRunResponse = usedLegacyRunStream
-      ? await readLegacyRunStream(workerResponse).then((legacy) => ({
-          status: legacy.error ? 'failed' : 'completed',
-          result: legacy.result,
-          outputRows: legacy.outputRows ?? undefined,
-          events: legacy.logs.map((message) => ({
-            type: 'log',
-            message,
-          })),
-          error: legacy.error ?? undefined,
-        }))
-      : ((await workerResponse.json()) as InlineWorkerRunResponse);
-    const logs = (parsed.events ?? []).flatMap((event) => {
-      if (
-        event &&
-        typeof event === 'object' &&
-        event.type === 'log' &&
-        typeof event.message === 'string'
-      ) {
-        return [event.message];
-      }
-      return [];
-    });
-    trace('coordinator.inline_child_response', responseStartedAt, {
-      status: parsed.status ?? null,
-      endpoint: usedLegacyRunStream ? '/run' : '/run-inline',
-      logCount: logs.length,
-      outputRows:
-        typeof parsed.outputRows === 'number' ? parsed.outputRows : null,
-      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 = {
-        message:
-          typeof parsed.error?.message === 'string'
-            ? parsed.error.message
-            : 'Inline child Worker failed.',
-        stack:
-          typeof parsed.error?.stack === 'string' ? parsed.error.stack : null,
-      };
-      recordCoordinatorPerfTrace({
-        runId: childRunId,
-        phase: 'coordinator.inline_child_boundary',
-        ms: Date.now() - startedAt,
-        graphHash: manifest.graphHash,
-        extra: {
-          parentRunId: input.parentRunId,
-          childPlayName,
-          action: 'failed',
-          mode: 'inline_dynamic_worker',
-          error: error.message,
-        },
-      });
-      const terminalAppendStartedAt = Date.now();
-      await appendRegisteredChildRunTerminal({
-        env: input.env,
-        baseUrl,
-        childExecutorToken: childToken,
-        childRunId,
-        status: 'failed',
-        error: error.message,
-      });
-      trace(
-        'coordinator.inline_child_terminal_ledger_append',
-        terminalAppendStartedAt,
-        { status: 'failed' },
-      );
-      return {
-        workflowId: childRunId,
-        runId: childRunId,
-        status: 'failed',
-        mode: 'inline_dynamic_worker',
-        error,
-        logs,
-        timings,
-      };
-    }
-    recordCoordinatorPerfTrace({
-      runId: childRunId,
-      phase: 'coordinator.inline_child_boundary',
-      ms: Date.now() - startedAt,
-      graphHash: manifest.graphHash,
-      extra: {
-        parentRunId: input.parentRunId,
-        childPlayName,
-        action: 'completed',
-        mode: 'inline_dynamic_worker',
-      },
-    });
-    const terminalAppendStartedAt = Date.now();
-    await appendRegisteredChildRunTerminal({
-      env: input.env,
-      baseUrl,
-      childExecutorToken: childToken,
-      childRunId,
-      status: 'completed',
-      result: parsed.result,
-    });
-    trace(
-      'coordinator.inline_child_terminal_ledger_append',
-      terminalAppendStartedAt,
-      { status: 'completed' },
-    );
-    return {
-      workflowId: childRunId,
-      runId: childRunId,
-      status: 'completed',
-      mode: 'inline_dynamic_worker',
-      result: parsed.result,
-      output: parsed.result,
-      logs,
-      timings,
-    };
-  } finally {
-    disposeRpcStub(response);
-    disposeRpcStub(entrypoint);
-  }
-}
-
-function isRetryableChildWorkflowSubmitError(error: unknown): boolean {
-  const message = error instanceof Error ? error.message : String(error);
-  return /timed out|timeout|fetch failed|ECONNRESET|ECONNREFUSED|UND_ERR_CONNECT_TIMEOUT|internal error/i.test(
-    message,
-  );
-}
-
-function isRetryableChildWorkflowSubmitResponse(
-  status: number,
-  body: string,
-): boolean {
-  if (
-    status === 408 ||
-    status === 429 ||
-    status === 502 ||
-    status === 503 ||
-    status === 504 ||
-    status === 530
-  ) {
-    return true;
-  }
-  return (
-    status === 500 &&
-    /COORDINATOR_WORKFLOW_ROUTE_FAILED|timeout exceeded when trying to connect|timed out|fetch failed|ECONNRESET|UND_ERR_CONNECT_TIMEOUT|internal error/i.test(
-      body,
-    )
-  );
+    ? Math.max(0, Math.floor(value))
+    : 0;
 }
 
-async function submitChildWorkflowThroughCoordinator(input: {
+async function restartWorkflowAfterPlatformReset(input: {
   env: CoordinatorEnv;
-  parentRunId: string;
-  body: Record<string, unknown>;
-  coordinatorUrl: string | null;
+  ctx?: ExecutionContext;
+  runId: string;
+  oldInstance: WorkflowInstance;
+  error: string;
+  status: InstanceStatus;
 }): Promise<{
-  response: Response;
-  responseText: string;
-  childRunId: string;
-  childPlayName: string;
-  startedAt: number;
-  timings: CoordinatorTiming[];
+  retried: boolean;
+  result: Record<string, unknown> | null;
 }> {
-  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,
+  const decision = decideWorkflowPlatformRetry({
+    workflowStatus: String(input.status.status ?? ''),
+    error: input.error,
+    retryAttempts: 0,
   });
-  if (!validated.ok) {
-    return {
-      response: Response.json(
-        { error: validated.error },
-        { status: validated.status },
-      ),
-      responseText: '',
-      childRunId: '',
-      childPlayName: '',
-      startedAt,
-      timings,
-    };
+  if (decision.action !== 'retry') {
+    return { retried: false, result: null };
   }
-  const { manifest, governance, childPlayName, orgId, parentExecutorToken } =
-    validated;
-  const childRunId = buildChildRunId({
-    playName: childPlayName,
-    parentRunId: input.parentRunId,
-    body: input.body,
-  });
-  const baseUrl = resolveRuntimeApiBaseUrl(input.env, input.body);
-
-  const prepareStartedAt = Date.now();
-  const { childToken, preloadedDbSessions, prepareTimings, transportTimings } =
-    await prepareInlineChildRunWithRuntime({
-      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,
-      manifest,
-      governance,
-      userEmail:
-        typeof input.body.userEmail === 'string' ? input.body.userEmail : '',
-      runtimeBackend: 'cf_workflows_dynamic_worker',
-      schedulerBackend: 'cf_workflows',
-      executionProfile: 'workers_edge',
-    });
-  trace(
-    'coordinator.child_submit_prepare',
-    prepareStartedAt,
-    manifest.graphHash,
-    {
-      childRunId,
-      childPlayName,
-      sessions: preloadedDbSessions.length,
-      prepareTimings,
-      transportTimings,
-    },
-  );
-
-  const params = buildChildWorkflowParams({
+  const claim = await claimWorkflowPlatformRetry({
     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();
-  let response: Response | null = null;
-  let responseText = '';
-  let lastSubmitError: unknown = null;
-  for (
-    let attempt = 0;
-    attempt <= CHILD_WORKFLOW_SUBMIT_RETRY_DELAYS_MS.length;
-    attempt += 1
-  ) {
-    try {
-      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,
-      });
-    } catch (error) {
-      lastSubmitError = error;
-      trace(
-        'coordinator.child_submit_workflow_attempt',
-        workflowSubmitStartedAt,
-        manifest.graphHash,
-        {
-          childRunId,
-          attempt: attempt + 1,
-          status: 'threw',
-          error: error instanceof Error ? error.message : String(error),
-        },
-      );
-      if (
-        attempt >= CHILD_WORKFLOW_SUBMIT_RETRY_DELAYS_MS.length ||
-        !isRetryableChildWorkflowSubmitError(error)
-      ) {
-        await markRegisteredChildRunFailed({
-          env: input.env,
-          baseUrl,
-          childExecutorToken: childToken,
-          childRunId,
-          error,
-        }).catch((markError) => {
-          recordCoordinatorEvent(
-            'error',
-            'coordinator.child_workflow_submit.failure_mark_failed',
-            '[coordinator] child workflow submit failure mark failed',
-            {
-              childRunId,
-              error:
-                markError instanceof Error
-                  ? markError.message
-                  : String(markError),
-            },
-          );
-        });
-        throw error;
-      }
-      await sleep(CHILD_WORKFLOW_SUBMIT_RETRY_DELAYS_MS[attempt] ?? 0);
-      continue;
-    }
-
-    responseText = await response.text().catch(() => '');
-    trace(
-      'coordinator.child_submit_workflow_attempt',
-      workflowSubmitStartedAt,
-      manifest.graphHash,
+    runId: input.runId,
+  }).catch((error) => {
+    recordCoordinatorEvent(
+      'warn',
+      'coordinator.workflow_platform_retry.claim_failed',
+      '[coordinator] workflow platform retry claim failed',
       {
-        childRunId,
-        attempt: attempt + 1,
-        status: response.status,
+        runId: input.runId,
+        error: error instanceof Error ? error.message : String(error),
       },
     );
-    if (
-      response.ok ||
-      attempt >= CHILD_WORKFLOW_SUBMIT_RETRY_DELAYS_MS.length ||
-      !isRetryableChildWorkflowSubmitResponse(response.status, responseText)
-    ) {
-      break;
-    }
-    lastSubmitError = `workflow submit returned ${response.status}: ${responseText.slice(0, 800)}`;
-    await sleep(CHILD_WORKFLOW_SUBMIT_RETRY_DELAYS_MS[attempt] ?? 0);
-  }
-  if (!response) {
-    throw lastSubmitError instanceof Error
-      ? lastSubmitError
-      : new Error(String(lastSubmitError));
+    return null;
+  });
+  if (!claim?.claimed || !claim.params) {
+    return { retried: false, result: null };
   }
-  trace(
-    'coordinator.child_submit_workflow',
-    workflowSubmitStartedAt,
-    manifest.graphHash,
-    { childRunId, status: response.status },
-  );
-  if (!response.ok) {
-    await markRegisteredChildRunFailed({
+  const retryInstanceId = workflowRetryInstanceId(input.runId, claim.attempts);
+  const retryStartedAt = Date.now();
+  let retryInstance: WorkflowInstance | null = null;
+  const retryParams = { ...claim.params, runAttempt: claim.attempts };
+  try {
+    retryInstance = await createDynamicWorkflowInstance({
       env: input.env,
-      baseUrl,
-      childExecutorToken: childToken,
-      childRunId,
-      error: `workflow submit returned ${response.status}: ${responseText.slice(0, 800)}`,
-    }).catch((markError) => {
-      recordCoordinatorEvent(
-        'error',
-        'coordinator.child_workflow_submit.failure_mark_failed',
-        '[coordinator] child workflow submit failure mark failed',
-        {
-          childRunId,
-          error:
-            markError instanceof Error ? markError.message : String(markError),
-        },
-      );
+      id: retryInstanceId,
+      params: workflowCreateParams(retryParams, {
+        params: retryParams,
+        paramsRef: claim.paramsRef,
+      }),
+      metadataParams: retryParams,
     });
-  }
-  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. 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
- * Workflows serializes the dynamic Worker's `env` map when it persists
- * workflow state. WorkerEntrypoint stubs ARE cloneable.
- *
- * Path allowlist: only `/api/v2/plays/*` and `/api/v2/integrations/*`.
- * Anything else is a sandbox-escape attempt and gets a loud 403 — the
- * coordinator must NOT proxy a play's request to internal admin routes
- * even if the play tries to construct such a URL.
- */
-export class RuntimeApi extends WorkerEntrypoint<CoordinatorEnv, undefined> {
-  async fetch(request: Request): Promise<Response> {
-    const incoming = new URL(request.url);
-    const allowed =
-      incoming.pathname.startsWith('/api/v2/plays/') ||
-      incoming.pathname.startsWith('/api/v2/integrations/');
-    if (!allowed) {
-      return new Response(
-        JSON.stringify({
-          error:
-            'RUNTIME_API binding only forwards /api/v2/plays/* and /api/v2/integrations/* paths',
-          attemptedPath: incoming.pathname,
-        }),
-        { status: 403, headers: { 'content-type': 'application/json' } },
-      );
-    }
-    const configuredApiBaseUrl =
-      typeof this.env.DEEPLINE_API_BASE_URL === 'string' &&
-      this.env.DEEPLINE_API_BASE_URL.trim()
-        ? this.env.DEEPLINE_API_BASE_URL.trim()
-        : 'https://code.deepline.com';
-    const target = new URL(
-      incoming.pathname + incoming.search,
-      configuredApiBaseUrl,
-    );
-    const forwarded = new Request(target.toString(), request);
-    const bypassToken = this.env.VERCEL_PROTECTION_BYPASS_TOKEN;
-    if (typeof bypassToken === 'string' && bypassToken) {
-      forwarded.headers.set('x-vercel-protection-bypass', bypassToken);
-    }
-    const res = await fetch(forwarded);
-    if (!res.ok) {
-      const body = await res
-        .clone()
-        .text()
-        .catch(() => '');
-      recordCoordinatorEvent(
-        'error',
-        'coordinator.runtime_api.proxy_failed',
-        '[RUNTIME_API] request failed',
-        {
-          path: incoming.pathname,
-          status: res.status,
-          targetOrigin: target.origin,
-          body: body.slice(0, 500),
+    await recordWorkflowInstanceId({
+      env: input.env,
+      runId: input.runId,
+      instanceId: retryInstance.id,
+    });
+    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,
         },
-      );
-    }
-    return res;
+      },
+    };
+  } finally {
+    disposeRpcStub(retryInstance);
   }
 }
 
@@ -3296,60 +1787,6 @@ export class CoordinatorControl extends WorkerEntrypoint<
   CoordinatorEnv,
   undefined
 > {
-  async submitChild(
-    parentRunId: string,
-    body: Record<string, unknown>,
-  ): Promise<InlineChildSubmitResult> {
-    return await executeChildInline({
-      env: this.env,
-      parentRunId,
-      body,
-    });
-  }
-
-  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>,
@@ -3420,25 +1857,6 @@ export class CoordinatorControl extends WorkerEntrypoint<
     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
@@ -3699,37 +2117,6 @@ export class DynamicWorkflow extends WorkflowEntrypoint<
                 const output = isRecord(result) ? result : null;
                 const terminalResult = output?.result ?? result;
                 const terminalStartedAt = Date.now();
-                const childTerminalStartedAt = Date.now();
-                try {
-                  const childTerminalPersisted =
-                    await appendWorkflowChildCompletedRunEvent({
-                      env,
-                      event: innerEvent,
-                      result: terminalResult,
-                    });
-                  if (childTerminalPersisted) {
-                    trace({
-                      runId: runIdForTrace,
-                      phase:
-                        'coordinator.child_terminal_ledger_append_completed',
-                      ms: Date.now() - childTerminalStartedAt,
-                      graphHash,
-                    });
-                  }
-                } catch (childTerminalError) {
-                  recordCoordinatorEvent(
-                    'warn',
-                    'coordinator.child_terminal.ledger_append_failed',
-                    '[coordinator] child terminal ledger append failed; preserving coordinator terminal cache',
-                    {
-                      runId: runIdForTrace,
-                      message:
-                        childTerminalError instanceof Error
-                          ? childTerminalError.message
-                          : String(childTerminalError),
-                    },
-                  );
-                }
                 try {
                   await writeCoordinatorTerminalState(env, {
                     runId: runIdForTrace,
@@ -4804,113 +3191,6 @@ async function handleWorkflowRoute(input: {
     }
   }
 
-  if (action === 'submit-child') {
-    const startedAt = Date.now();
-    try {
-      const body = (await request.json().catch(() => null)) as Record<
-        string,
-        unknown
-      > | null;
-      if (!body || typeof body !== 'object') {
-        return Response.json(
-          {
-            error: {
-              code: 'CHILD_SUBMIT_BODY_REQUIRED',
-              message: 'submit-child requires a JSON body.',
-              phase: 'coordinator_child_submit',
-              parentRunId: runId,
-            },
-          },
-          { status: 400 },
-        );
-      }
-      const {
-        response: submitResponse,
-        responseText,
-        childRunId,
-        childPlayName,
-      } = await submitChildWorkflowThroughCoordinator({
-        env,
-        parentRunId: runId,
-        body,
-        coordinatorUrl: new URL(request.url).origin,
-      });
-      recordCoordinatorPerfTrace({
-        runId,
-        phase: 'coordinator.child_submit',
-        ms: Date.now() - startedAt,
-        extra: { status: submitResponse.status, childRunId },
-      });
-      recordCoordinatorEvent(
-        'info',
-        'play.runtime.span',
-        '[play.runtime.span]',
-        {
-          event: 'play.runtime.span',
-          phase: 'coordinator_child_submit',
-          runId,
-          parentRunId: runId,
-          childRunId,
-          playName: childPlayName,
-          ms: Date.now() - startedAt,
-          status: submitResponse.ok ? 'ok' : 'failed',
-          ...(submitResponse.ok
-            ? {}
-            : { errorCode: 'COORDINATOR_CHILD_SUBMIT_FAILED' }),
-        },
-      );
-      if (!submitResponse.ok) {
-        return new Response(responseText, {
-          status: submitResponse.status,
-          headers: {
-            'content-type':
-              submitResponse.headers.get('content-type') ?? 'application/json',
-            'cache-control': 'no-store',
-          },
-        });
-      }
-      return Response.json(
-        {
-          workflowId: childRunId,
-          runId: childRunId,
-          status: 'started',
-          coordinator: JSON.parse(responseText || '{}'),
-        },
-        {
-          headers: {
-            'cache-control': 'no-store',
-          },
-        },
-      );
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      recordCoordinatorEvent(
-        'error',
-        'coordinator.child_submit.error',
-        '[coordinator.child_submit.error]',
-        {
-          runId,
-          ms: Date.now() - startedAt,
-          error: message,
-        },
-      );
-      return Response.json(
-        {
-          error: {
-            code: 'COORDINATOR_CHILD_SUBMIT_FAILED',
-            message,
-            phase: 'coordinator_child_submit',
-            parentRunId: runId,
-          },
-        },
-        {
-          status: 500,
-          headers: { 'cache-control': 'no-store' },
-        },
-      );
-    }
-  }
-
   if (action === 'tail') {
     const url = new URL(request.url);
     const waitMs = Math.min(
@@ -5120,25 +3400,6 @@ 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) => {
-          recordCoordinatorEvent(
-            'warn',
-            'coordinator.child_terminal.cache_write_failed',
-            '[coordinator] child terminal cache write failed',
-            {
-              runId,
-              eventKey,
-              error: error instanceof Error ? error.message : String(error),
-            },
-          );
-        });
-      }
       await instance.sendEvent({
         type: workflowEventType(eventType),
         payload: body,
@@ -5943,7 +4204,6 @@ async function handleCoordinatorWarmup(
     packagedFiles: null,
     contractSnapshot: null,
     executionPlan: null,
-    playCallGovernance: null,
     dynamicWorkerCode: null,
     executorToken: 'coordinator-warmup',
     baseUrl: env.DEEPLINE_API_BASE_URL,
@@ -6057,14 +4317,6 @@ function makeRuntimeApiEnvBinding(env: CoordinatorEnv): {
 function makeCoordinatorControlBinding():
   | {
       COORDINATOR: {
-        submitChild(
-          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>,
@@ -6080,11 +4332,6 @@ function makeCoordinatorControlBinding():
         readTerminalState(
           runId: string,
         ): Promise<CoordinatorTerminalState | null>;
-        readChildTerminalState(
-          parentRunId: string,
-          eventKey: string,
-          timeoutMs?: number,
-        ): Promise<CoordinatorChildTerminalState | null>;
         rateAcquire(input: {
           bucketId: string;
           rules: Array<{
@@ -6104,14 +4351,6 @@ function makeCoordinatorControlBinding():
   | Record<string, never> {
   const exports = workersExports as unknown as {
     CoordinatorControl?: (init: { props: undefined }) => {
-      submitChild(
-        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>,
@@ -6124,11 +4363,6 @@ function makeCoordinatorControlBinding():
       readTerminalState(
         runId: string,
       ): Promise<CoordinatorTerminalState | null>;
-      readChildTerminalState(
-        parentRunId: string,
-        eventKey: string,
-        timeoutMs?: number,
-      ): Promise<CoordinatorChildTerminalState | null>;
       rateAcquire(input: {
         bucketId: string;
         rules: Array<{