deepline 0.1.227 → 0.1.229

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

@@ -62,13 +62,6 @@ import {
   pacingPolicyFromUnknownQueueHints,
   type ResolvedPacingPolicy,
 } from '../../../shared_libs/play-runtime/pacing';
-import {
-  awaitChildTerminal,
-  type ChildPlayTerminalWaitResult,
-  type WorkflowStepLike,
-} from './child-play-await';
-import { submitChildPlayThroughCoordinator } from './child-play-submit';
-import { createRunScopedChildManifestResolver } from './child-manifest-resolver';
 import { isRetryableWorkerRuntimeApiError } from './runtime-api-retry';
 import { formatCustomerConsoleValue } from './runtime/customer-console';
 import {
@@ -91,12 +84,8 @@ import {
   createToolExecuteHttpFailureAttemptTracker,
   parseToolExecuteAuthScopeChangedError,
 } from '../../../shared_libs/play-runtime/tool-execute-retry-policy';
-import type { PlayCallGovernanceSnapshot } from '../../../shared_libs/play-runtime/scheduler-backend';
 import type { PreloadedRuntimeDbSession } from '../../../shared_libs/play-runtime/db-session';
-import type {
-  PlayRuntimeManifest,
-  PlayRuntimeManifestMap,
-} from '../../../shared_libs/plays/compiler-manifest';
+import type { PlayRuntimeManifest } from '../../../shared_libs/plays/compiler-manifest';
 import {
   deriveToolRequestIdentity,
   derivePlayRowIdentity,
@@ -105,10 +94,7 @@ import {
   stableStringify,
 } from '../../../shared_libs/plays/row-identity';
 import { createDeferredPlayDataset } from '../../../shared_libs/plays/dataset';
-import {
-  buildDurableCtxCallCacheKey,
-  buildDurableRunPlayInvocationScope,
-} from '../../../shared_libs/play-runtime/durable-call-cache';
+import { buildDurableCtxCallCacheKey } from '../../../shared_libs/play-runtime/durable-call-cache';
 import {
   resolveRuntimeToolReceiptWaitMaxAttempts,
   resolveRuntimeToolReceiptWaitTimeoutMs,
@@ -140,6 +126,11 @@ import type {
   PlayRunLedgerStepProgress,
   PlayRunLedgerStepStatus,
 } from '../../../shared_libs/play-runtime/run-ledger';
+import {
+  MAX_LEDGER_LOG_LINE_LENGTH,
+  MAX_LEDGER_LOG_LINES_PER_EVENT,
+} from '../../../shared_libs/play-runtime/ledger-safe-payload';
+import { partitionWorkerLedgerEvents } from './runtime/ledger-event-batches';
 import type { PlayHarnessRpc } from '../../play-harness-worker/src/rpc-types';
 import {
   createCsvDatasetHandle,
@@ -205,7 +196,6 @@ import {
   runtimeMapJsonByteLength,
 } from '../../../shared_libs/play-runtime/map-memory-limits';
 import { createSerialTaskQueue } from '../../../shared_libs/play-runtime/serial-task-queue';
-import { resolveChildExecutionPlacement as resolveChildExecutionStrategy } from '../../../shared_libs/play-runtime/child-execution-placement';
 // The harness stub forwards leaf calls (validation, runtime-api HTTP) into
 // the long-lived Play Harness Worker via env.HARNESS. We import the
 // `setHarnessBinding` setter eagerly so it's available the moment
@@ -418,10 +408,6 @@ type RunRequest = {
   contractSnapshot?: unknown;
   /** Deepline-owned compact execution plan. Public SDK/users never see this. */
   executionPlan?: ExecutionPlan | null;
-  /** Trusted child play launch manifests carried by the top-level Vercel submit. */
-  childPlayManifests?: PlayRuntimeManifestMap | null;
-  /** Internal ctx.runPlay lineage. Public SDK/users never see this. */
-  playCallGovernance?: PlayCallGovernanceSnapshot | null;
   preloadedDbSessions?: PreloadedRuntimeDbSession[] | null;
   /** Cloudflare coordinator URL for direct Workflow control-plane signals. */
   coordinatorUrl?: string | null;
@@ -634,41 +620,8 @@ type WorkerEnv = {
       body: string;
     }>;
   };
-  /**
-   * Loopback RPC binding into the coordinator Worker. Used for CF-to-CF
-   * child orchestration so nested plays do not bounce through a public
-   * coordinator URL when both caller and callee are already inside the same
-   * Cloudflare Worker graph.
-   */
+  /** Loopback RPC binding for runtime observability and rate coordination. */
   COORDINATOR?: {
-    submitChild(
-      parentRunId: string,
-      body: Record<string, unknown>,
-    ): Promise<{
-      workflowId?: string;
-      runId?: string;
-      status?: string;
-      mode?: string;
-      output?: unknown;
-      result?: unknown;
-      error?: unknown;
-      logs?: string[];
-      timings?: Array<{ phase: string; ms: number }>;
-    }>;
-    submitWorkflowChild?(
-      parentRunId: string,
-      body: Record<string, unknown>,
-    ): Promise<{
-      workflowId?: string;
-      runId?: string;
-      status?: string;
-      mode?: string;
-      output?: unknown;
-      result?: unknown;
-      error?: unknown;
-      logs?: string[];
-      timings?: Array<{ phase: string; ms: number }>;
-    }>;
     signal(
       runId: string,
       body: Record<string, unknown>,
@@ -682,11 +635,6 @@ type WorkerEnv = {
       event: Record<string, unknown>,
     ): Promise<void>;
     readTerminalState?(runId: string): Promise<Record<string, unknown> | null>;
-    readChildTerminalState?(
-      parentRunId: string,
-      eventKey: string,
-      timeoutMs?: number,
-    ): Promise<Record<string, unknown> | null>;
     /**
      * Distributed Rate State Backend RPC. Routes to the per-(org,provider)
      * rate-bucket Durable Object so the request window is global across
@@ -1225,29 +1173,11 @@ async function drainRunnerPerfTraces(req: RunRequest): Promise<void> {
 
 let workerRequestSequence = 0;
 
-const workerRunPlayRowContext = new AsyncLocalStorage<{
-  tableNamespace: string;
-  rowKey: string;
-  fieldName: string;
-}>();
-
 function makeRequestId(): string {
   workerRequestSequence = (workerRequestSequence + 1) % Number.MAX_SAFE_INTEGER;
   return `worker-request-${workerRequestSequence}`;
 }
 
-async function executeFreshChildInvocation<T>(
-  input: {
-    parentRunId: string;
-    key: string;
-    invocationScope: string;
-  },
-  execute: (invocationId: string) => Promise<T>,
-): Promise<T> {
-  const invocationId = `${input.parentRunId}:runPlay:${input.key}:${input.invocationScope}`;
-  return await execute(invocationId);
-}
-
 function makeRuntimeSheetAttempt(input: {
   runId: string;
   runAttempt?: number | null;
@@ -1478,65 +1408,14 @@ async function postRuntimeApiBestEffort(
   }
 }
 
-async function readDurableChildRunTerminalState(input: {
-  baseUrl: string;
-  executorToken: string;
-  parentRunId: string;
-  childRunId: string;
-  childPlayName: string;
-  timeoutMs?: number;
-}): Promise<{ data?: unknown } | null> {
-  const response = await postRuntimeApi<{
-    state?: {
-      data?: unknown;
-      reason?: string;
-      status?: string;
-      runId?: string;
-      playName?: string;
-      parentRunId?: string | null;
-    } | null;
-  }>(
-    input.baseUrl,
-    input.executorToken,
-    {
-      action: 'read_child_run_terminal_snapshot',
-      parentRunId: input.parentRunId,
-      childRunId: input.childRunId,
-      childPlayName: input.childPlayName,
-    },
-    {
-      timeoutMsOverride: input.timeoutMs,
-      timeoutErrorMessage: `[play-harness] child run terminal snapshot read timed out after ${Math.max(
-        1,
-        Math.ceil(input.timeoutMs ?? RUNTIME_API_TIMEOUT_MS),
-      )}ms. childRunId=${input.childRunId}`,
-    },
-  );
-  return response.state ?? null;
-}
-
-function workflowEventType(name: string): string {
-  const normalized = name
-    .trim()
-    .replace(/[^A-Za-z0-9_-]+/g, '_')
-    .replace(/^_+|_+$/g, '')
-    .slice(0, 100);
-  return normalized || 'deepline_event';
-}
-
-function normalizeContextKey(key: unknown, operation: string): string {
-  if (typeof key !== 'string' || !key.trim()) {
-    throw new Error(`ctx.${operation}(...) requires a non-empty key.`);
-  }
-  return key
-    .trim()
-    .replace(/[^A-Za-z0-9_.:-]+/g, '_')
-    .slice(0, 120);
-}
-
 function resolvePlayRefName(playRef: unknown): string {
-  if (typeof playRef === 'string') return playRef.trim();
-  if (typeof playRef === 'function') {
+  if (typeof playRef === 'string' && playRef.trim()) {
+    return playRef.trim();
+  }
+  if (
+    playRef &&
+    (typeof playRef === 'object' || typeof playRef === 'function')
+  ) {
     const record = playRef as unknown as Record<string | symbol, unknown>;
     const playName = record.playName;
     if (typeof playName === 'string' && playName.trim()) return playName.trim();
@@ -1559,189 +1438,11 @@ function resolvePlayRefName(playRef: unknown): string {
   return '';
 }
 
-function extractChildPlayOutput(status: Record<string, unknown>): unknown {
-  const result = status.result;
-  if (isRecord(result) && 'output' in result) {
-    return result.output;
-  }
-  return result ?? null;
-}
-
-function hydrateChildPlayOutputDatasets(input: {
-  req: RunRequest;
-  childRunId: string;
-  childPlayName: string;
-  value: unknown;
-}): unknown {
-  return hydrateSerializedResultDatasets(input.value, (dataset) => {
-    const tableNamespace = dataset.tableNamespace?.trim();
-    if (!tableNamespace) {
-      return dataset;
-    }
-    const count = Math.max(0, Math.floor(dataset.count));
-    const previewRows = dataset.preview.filter(isRecord);
-    return createPersistedDatasetHandle({
-      playName: input.childPlayName,
-      name: tableNamespace,
-      count,
-      datasetKind: dataset.datasetKind,
-      previewRows,
-      cachedRows: count <= previewRows.length ? previewRows : null,
-      sourceLabel: dataset.sourceLabel ?? null,
-      readRows: async ({ limit, offset }) => {
-        const result = await harnessReadSheetDatasetRows({
-          baseUrl: input.req.baseUrl,
-          executorToken: input.req.executorToken,
-          orgId: input.req.orgId,
-          playName: input.childPlayName,
-          tableNamespace,
-          runId: input.childRunId,
-          limit,
-          offset,
-          userEmail: input.req.userEmail,
-          preloadedDbSessions: input.req.preloadedDbSessions ?? null,
-        });
-        return result.rows as Array<Record<string, unknown>>;
-      },
-      trace: (phase, ms, extra) =>
-        recordRunnerPerfTrace({
-          req: input.req,
-          phase,
-          ms,
-          extra: {
-            ...(extra ?? {}),
-            childRunId: input.childRunId,
-            childPlayName: input.childPlayName,
-          },
-        }),
-      nowMs,
-      workProgress: dataset._metadata?.workProgress,
-    });
-  });
-}
-
-async function hashChildPlayEventKey(input: unknown): Promise<string> {
-  return (await hashJson(input)).slice(0, 32);
-}
-
-type RuntimeResolvedPlayResponse = {
-  manifest?: PlayRuntimeManifest | null;
-};
-
-async function resolveAuthorizedWorkerChildManifest(input: {
-  req: RunRequest;
-  playRef: string;
-}): Promise<PlayRuntimeManifest | null> {
-  const response = await postRuntimeApi<RuntimeResolvedPlayResponse>(
-    input.req.baseUrl,
-    input.req.executorToken,
-    {
-      action: 'resolve_play',
-      playRef: input.playRef,
-      artifactKind: 'esm_workers',
-    },
-    {
-      runtimeTestFaultHeader: input.req.runtimeTestFaultHeader,
-      timeoutMsOverride: 30_000,
-    },
-  );
-  return response.manifest ?? null;
-}
-
-async function childPlayEventKey(input: {
-  key: string;
-  workflowId: string;
-}): Promise<string> {
-  const readableKey = workflowEventType(input.key).slice(0, 40);
-  const digest = await hashChildPlayEventKey({
-    key: input.key,
-    workflowId: input.workflowId,
-  });
-  return `child_play_${digest}_${readableKey}`;
-}
-
 function workflowTimeoutFromMs(timeoutMs: number): string {
   const seconds = Math.max(1, Math.ceil(timeoutMs / 1000));
   return `${seconds} second${seconds === 1 ? '' : 's'}`;
 }
 
-async function signalParentPlayTerminal(input: {
-  req: RunRequest;
-  status: 'completed' | 'failed' | 'cancelled';
-  result?: unknown;
-  error?: string | null;
-}): Promise<void> {
-  const governance = input.req.playCallGovernance;
-  if (!governance?.parentRunId || !governance.key) return;
-  const eventKey = await childPlayEventKey({
-    key: governance.key,
-    workflowId: input.req.runId,
-  });
-  const data = {
-    type: 'play.child.terminal',
-    parentRunId: governance.parentRunId,
-    childRunId: input.req.runId,
-    playName: input.req.playName,
-    key: governance.key,
-    status: input.status,
-    ...(input.result !== undefined ? { result: input.result } : {}),
-    ...(input.error
-      ? {
-          error: {
-            code:
-              input.status === 'cancelled' ? 'CHILD_CANCELLED' : 'CHILD_FAILED',
-            message: input.error,
-            phase: 'child_terminal',
-            runId: input.req.runId,
-            parentRunId: governance.parentRunId,
-            childRunId: input.req.runId,
-          },
-        }
-      : {}),
-    emittedAt: nowMs(),
-  };
-  const signalBody = {
-    signal: 'integration_event',
-    eventKey,
-    data,
-  };
-  if (cachedCoordinatorBinding) {
-    await cachedCoordinatorBinding.signal(governance.parentRunId, signalBody);
-    return;
-  }
-  const coordinatorUrl = input.req.coordinatorUrl?.trim();
-  if (coordinatorUrl) {
-    const res = await fetch(
-      `${coordinatorUrl.replace(/\/$/, '')}/workflow/${encodeURIComponent(
-        governance.parentRunId,
-      )}/signal`,
-      {
-        method: 'POST',
-        headers: {
-          'x-deepline-request-id': makeRequestId(),
-          ...coordinatorRequestHeaders({
-            runId: governance.parentRunId,
-            contentType: 'application/json',
-            internalToken: input.req.coordinatorInternalToken,
-          }),
-        },
-        body: JSON.stringify(signalBody),
-      },
-    );
-    if (res.ok) {
-      return;
-    }
-    const text = await res.text().catch(() => '');
-    throw new Error(
-      text.slice(0, 800) ||
-        `Coordinator parent signal failed with ${res.status}.`,
-    );
-  }
-  throw new Error(
-    'Child play terminal signaling requires a coordinator binding in the cf-workflows runtime.',
-  );
-}
-
 async function executeTool(
   req: RunRequest,
   args: {
@@ -1875,6 +1576,25 @@ function normalizeToolExecuteArgs(request: unknown): {
   };
 }
 
+function workflowEventType(name: string): string {
+  const normalized = name
+    .trim()
+    .replace(/[^A-Za-z0-9_-]+/g, '_')
+    .replace(/^_+|_+$/g, '')
+    .slice(0, 100);
+  return normalized || 'deepline_event';
+}
+
+function normalizeContextKey(key: unknown, operation: string): string {
+  if (typeof key !== 'string' || !key.trim()) {
+    throw new Error(`ctx.${operation}(...) requires a non-empty key.`);
+  }
+  return key
+    .trim()
+    .replace(/[^A-Za-z0-9_.:-]+/g, '_')
+    .slice(0, 120);
+}
+
 function integrationEventType(eventKey: string): string {
   return workflowEventType(`integration_event_${eventKey}`);
 }
@@ -3933,34 +3653,6 @@ function formatWorkerRowFailureMessage(error: unknown): string {
   return message.length > 1_000 ? `${message.slice(0, 1_000)}…` : message;
 }
 
-function childPipelineUsesCtxDataset(
-  pipeline: PlayStaticPipeline | null | undefined,
-): boolean {
-  if (!pipeline) return false;
-  if (typeof pipeline.tableNamespace === 'string' && pipeline.tableNamespace) {
-    return true;
-  }
-  if (pipeline.sheetContract) {
-    return true;
-  }
-  return flattenStaticPipeline(pipeline).some((substep) => {
-    if (substep.type === 'dataset') return true;
-    if (!isRecord(substep)) return false;
-    return (
-      ('tableNamespace' in substep &&
-        typeof substep.tableNamespace === 'string' &&
-        substep.tableNamespace.length > 0) ||
-      ('sheetContract' in substep && Boolean(substep.sheetContract))
-    );
-  });
-}
-
-/**
- * Build the per-(org,provider) rate port the distributed Rate State Backend
- * RPCs through. When the coordinator binding (or its rate RPCs) is absent we
- * fail OPEN — grant immediately — matching customer-rate-limiter semantics so a
- * miswired binding degrades pacing without stalling the run.
- */
 function createCoordinatorRatePort(req: RunRequest): CoordinatorRatePort {
   return {
     async rateAcquire(input) {
@@ -4174,46 +3866,20 @@ function createWorkerPacingResolver(req: RunRequest): WorkerPacingResolver {
 }
 
 /**
- * Build the Governor's lineage snapshot for this worker, seeded from the
- * inherited PlayCallGovernanceSnapshot (threaded via internalRunPlay) so play-
- * call budgets accumulate down the dispatch tree across isolates. The current
- * play id is always `req.playName` so the per-parent child-call counter keys off
- * the executing play (matching the prior worker behavior). Per-run counters the
- * worker lineage does not carry (tool/retry/descendant/waterfall) seed at 0 —
- * these are runaway guards, not exact cross-isolate ledgers, so a per-worker
- * reset is acceptable and matches the Governor contract.
+ * The retired workers-edge runtime has no child-run scheduling. Its Governor
+ * therefore starts from this top-level run only.
  */
 function resumeGovernanceFromRequest(req: RunRequest): GovernanceSnapshot {
-  const inherited = req.playCallGovernance;
-  const rootRunId = inherited?.rootRunId || req.runId;
-  const ancestryPlayIds = inherited?.ancestryPlayIds?.length
-    ? // Per the lineage validator the inherited tail equals the parent; ensure
-      // the chain ends with the currently-executing play for the cycle guard.
-      inherited.ancestryPlayIds[inherited.ancestryPlayIds.length - 1] ===
-      req.playName
-      ? [...inherited.ancestryPlayIds]
-      : [...inherited.ancestryPlayIds, req.playName]
-    : [req.playName];
-  const ancestryRunIds =
-    rootRunId === req.runId ? [req.runId] : [rootRunId, req.runId];
   return {
-    rootRunId,
+    rootRunId: req.runId,
     currentRunId: req.runId,
     currentPlayId: req.playName,
-    ancestryPlayIds,
-    ancestryRunIds,
-    callDepth: inherited?.callDepth ?? 0,
-    // Seed every lineage-global budget counter from the inherited snapshot so
-    // descendant/tool/retry/waterfall budgets accumulate across isolates exactly
-    // as they do across the cjs forkChild lineage. Without this they would reset
-    // to 0 in each isolate and become per-worker — contradicting the Governor's
-    // lineage-global budget contract. Fail-safe to 0 for older callers.
-    playCallCount: inherited?.playCallCount ?? 0,
-    toolCallCount: inherited?.toolCallCount ?? 0,
-    retryCount: inherited?.retryCount ?? 0,
-    descendantCount: inherited?.descendantCount ?? 0,
-    waterfallStepExecutions: inherited?.waterfallStepExecutions ?? 0,
-    parentChildCalls: {},
+    ancestryPlayIds: [req.playName],
+    ancestryRunIds: [req.runId],
+    callDepth: 0,
+    toolCallCount: 0,
+    retryCount: 0,
+    waterfallStepExecutions: 0,
   };
 }
 
@@ -4226,7 +3892,7 @@ function createGovernorForRun(req: RunRequest): {
     adapter: 'esm_workers',
     scope: {
       orgId: req.orgId,
-      rootRunId: req.playCallGovernance?.rootRunId ?? req.runId,
+      rootRunId: req.runId,
     },
     rateState: new CoordinatorRateStateBackend(createCoordinatorRatePort(req)),
     budgetState: new BlockReservingBudgetStateBackend(
@@ -4254,7 +3920,7 @@ function createGovernorForRun(req: RunRequest): {
  *   - ctx.csv(filename | inline rows)  (calls runtime API for file resolve)
  *   - ctx.dataset(name, rows).withColumn(name, resolver).run(opts)
  *   - ctx.tools.execute({ id, tool, input, ... })
- *   - ctx.runPlay(key, playRef, input, opts)
+ *   - ctx.runPlay(...), which rejects with CTX_RUN_PLAY_INLINE_ONLY
  *
  * Not supported (will throw):
  *   - ctx.fetch, checkpoints, etc.
@@ -4284,16 +3950,7 @@ function createMinimalWorkerCtx(
     createWorkerToolActionCacheVersionResolver(req);
   const resolveToolAuthScopeDigest =
     createWorkerToolAuthScopeDigestResolver(req);
-  // Play-call depth/count/per-parent budgets, child-play concurrency, and the
-  // lineage snapshot are owned by the Governor (createGovernorForRun above).
-  // The worker keeps only substrate mechanism here.
   const stepCallCounts: Record<string, number> = {};
-  const resolveChildManifest = createRunScopedChildManifestResolver({
-    scopeKey: `${req.orgId}:${req.runId}:${req.runAttempt}`,
-    preloaded: req.childPlayManifests,
-    resolveManifest: (playRef) =>
-      resolveAuthorizedWorkerChildManifest({ req, playRef }),
-  });
   const secretRedactor = createSecretRedactionContext();
 
   const resolveSecretAuth = async (auth?: SecretAuth) => {
@@ -4332,8 +3989,6 @@ function createMinimalWorkerCtx(
       : { [auth.header.toLowerCase()]: value };
   };
 
-  const rootGovernance = req.playCallGovernance;
-  const rootRunId = rootGovernance?.rootRunId ?? req.runId;
   const receiptStore = createHarnessWorkerReceiptStore({
     executorToken: req.executorToken,
     orgId: req.orgId,
@@ -4510,23 +4165,6 @@ function createMinimalWorkerCtx(
     persistenceLatch: rootPersistenceLatch,
     receiptSalvage,
   });
-  // Local ancestry chain that always ENDS with the currently-executing play
-  // (req.playName). The /api/v2/plays/run lineage validator requires the
-  // submitted ancestry's tail to equal the executor token's play name (i.e.
-  // the caller). Normalizing here keeps both the cycle-detection check below
-  // and the runPlay submission honest: at root we start with [req.playName],
-  // and for nested calls we append req.playName onto the parent-supplied
-  // chain (which per contract ends with the parent that submitted us).
-  const ancestryPlayIds = ((): string[] => {
-    if (!rootGovernance?.ancestryPlayIds?.length) {
-      return [req.playName];
-    }
-    const inherited = rootGovernance.ancestryPlayIds;
-    return inherited[inherited.length - 1] === req.playName
-      ? inherited
-      : [...inherited, req.playName];
-  })();
-  const callDepth = rootGovernance?.callDepth ?? 0;
   const runMap = async <T extends Record<string, unknown>>(
     name: string,
     rows: WorkerDatasetInput<T>,
@@ -5590,49 +5228,37 @@ function createMinimalWorkerCtx(
                             })
                           : null,
                     });
-                    const resolved = await workerRunPlayRowContext.run(
-                      {
-                        tableNamespace: name,
-                        rowKey: entry.rowKey,
-                        fieldName: key,
-                      },
-                      () =>
-                        executeWorkerStepResolver(
-                          value,
-                          enriched,
-                          rowCtx,
-                          absoluteIndex,
-                          previousCell,
-                          isWorkerStepProgram(value)
-                            ? {
-                                parentField: key,
-                                path: [],
-                                outputs: stepProgramOutputs,
-                                onOutput: async (stepOutput) => {
-                                  generatedOutputFields.add(
-                                    stepOutput.columnName,
-                                  );
-                                  const status =
-                                    stepOutput.status ?? 'completed';
-                                  if (status === 'skipped')
-                                    stepCellsSkipped += 1;
-                                  else stepCellsCompleted += 1;
-                                  await enqueueLiveRowUpdate({
-                                    key: entry.rowKey,
-                                    dataPatch: {
-                                      [stepOutput.columnName]: stepOutput.value,
-                                    },
-                                    cellMetaPatch: {
-                                      [stepOutput.columnName]: {
-                                        status,
-                                        stage: stepOutput.stepId,
-                                      },
-                                    },
-                                  });
+                    const resolved = await executeWorkerStepResolver(
+                      value,
+                      enriched,
+                      rowCtx,
+                      absoluteIndex,
+                      previousCell,
+                      isWorkerStepProgram(value)
+                        ? {
+                            parentField: key,
+                            path: [],
+                            outputs: stepProgramOutputs,
+                            onOutput: async (stepOutput) => {
+                              generatedOutputFields.add(stepOutput.columnName);
+                              const status = stepOutput.status ?? 'completed';
+                              if (status === 'skipped') stepCellsSkipped += 1;
+                              else stepCellsCompleted += 1;
+                              await enqueueLiveRowUpdate({
+                                key: entry.rowKey,
+                                dataPatch: {
+                                  [stepOutput.columnName]: stepOutput.value,
+                                },
+                                cellMetaPatch: {
+                                  [stepOutput.columnName]: {
+                                    status,
+                                    stage: stepOutput.stepId,
+                                  },
                                 },
-                              }
-                            : undefined,
-                        ),
+                              });
+                            },
+                          }
+                        : undefined,
                     );
                     enriched[key] = resolved.value;
                     fieldOutputs[key] = resolved.value;
@@ -6966,438 +6592,20 @@ function createMinimalWorkerCtx(
       key: string,
       playRef: string | { playName?: string; name?: string },
       input: Record<string, unknown>,
-      options?: {
+      _options?: {
         description?: string;
         timeoutMs?: number;
         execution?: 'inline' | 'child-workflow';
       },
     ): Promise<unknown> {
-      const normalizedKey = normalizeContextKey(key, 'runPlay');
-      const resolvedName = resolvePlayRefName(playRef);
+      normalizeContextKey(key, 'runPlay');
       assertNoSecretTaint(input, 'ctx.runPlay input');
+      const resolvedName = resolvePlayRefName(playRef);
       if (!resolvedName) {
         throw new Error('ctx.runPlay(...) requires a resolvable play name.');
       }
-      const childManifest = await resolveChildManifest(resolvedName);
-      const rowScope = workerRunPlayRowContext.getStore();
-      const invocationScope = buildDurableRunPlayInvocationScope({
-        childPlayName: resolvedName,
-        input,
-        rowScope: rowScope
-          ? {
-              fieldName: rowScope.fieldName,
-              rowKey: rowScope.rowKey,
-              tableNamespace: rowScope.tableNamespace,
-            }
-          : null,
-      });
-      return await executeFreshChildInvocation(
-        {
-          parentRunId: req.runId,
-          key: normalizedKey,
-          invocationScope,
-        },
-        async (childInvocationId) => {
-          // The Governor owns the play-call lineage: forkChild does the cycle
-          // guard, depth/per-parent/playCall/descendant budget charges, and
-          // returns the snapshot to thread into the child so budgets accumulate
-          // across isolates. Every ctx.runPlay call is a fresh child invocation.
-          const childRunId = `${req.runId}:child:${childInvocationId}`;
-          // Checkpoint governance admission separately from the child result.
-          // Workflow replay reuses this admission and the coordinator's stable
-          // child launch identity, but ctx.runPlay never caches child output.
-          const forkChild = () =>
-            governor.forkChild({
-              childPlayName: resolvedName,
-              childRunId,
-            });
-          const childGovernance = workflowStep
-            ? await (
-                workflowStep.do as unknown as <T>(
-                  name: string,
-                  callback: () => Promise<T>,
-                ) => Promise<T>
-              )(
-                `runPlay-governance:${sha256Hex(childInvocationId).slice(0, 24)}`,
-                forkChild,
-              )
-            : await forkChild();
-          const nextDepth = childGovernance.callDepth;
-          const nextParentCalls =
-            governor.snapshot().parentChildCalls[req.playName] ?? 0;
-
-          emitEvent({
-            type: 'log',
-            level: 'info',
-            message: `Starting child play ${resolvedName} (${normalizedKey})`,
-            ts: nowMs(),
-          });
-          if (!childManifest) {
-            throw new Error(
-              `ctx.runPlay(${normalizedKey}) cannot start ${resolvedName}: not callable.`,
-            );
-          }
-          const childIsDatasetBacked = childPipelineUsesCtxDataset(
-            childManifest.staticPipeline,
-          );
-          const childWaitsForEvent = (
-            childManifest.staticPipeline
-              ? flattenStaticPipeline(childManifest.staticPipeline)
-              : []
-          ).some(
-            (step) =>
-              step.type === 'tool' &&
-              (step.isEventWait || step.toolId === 'test_wait_for_event'),
-          );
-          const authoredWorkflow =
-            options?.timeoutMs != null ||
-            childIsDatasetBacked ||
-            childWaitsForEvent;
-          if (options?.execution === 'inline' && authoredWorkflow) {
-            throw new Error(
-              `ctx.runPlay("${resolvedName}") requested inline execution for a child that requires a workflow.`,
-            );
-          }
-          const childExecutionDecision = resolveChildExecutionStrategy({
-            requiresWorkflow: authoredWorkflow,
-            execution: options?.execution,
-          });
-          const childNeedsWorkflowScheduler =
-            childExecutionDecision.strategy === 'scheduled';
-          if (rowScope && childNeedsWorkflowScheduler) {
-            throw new Error(
-              `ctx.runPlay("${resolvedName}") cannot start a child workflow per dataset row.`,
-            );
-          }
-          recordRunnerOperationalSpan(req, {
-            event: 'play.runtime.span',
-            phase: 'child_route',
-            runId: req.runId,
-            parentRunId: req.runId,
-            playName: resolvedName,
-            graphHash: req.graphHash ?? null,
-            depth: nextDepth,
-            fanoutIndex: nextParentCalls - 1,
-            childIsDatasetBacked,
-            childNeedsWorkflowScheduler,
-            hasStaticPipeline: Boolean(childManifest.staticPipeline),
-            childTableNamespace:
-              typeof childManifest.staticPipeline?.tableNamespace === 'string'
-                ? childManifest.staticPipeline.tableNamespace
-                : null,
-            childStageCount: Array.isArray(childManifest.staticPipeline?.stages)
-              ? childManifest.staticPipeline.stages.length
-              : null,
-            childSubstepCount: Array.isArray(
-              childManifest.staticPipeline?.substeps,
-            )
-              ? childManifest.staticPipeline.substeps.length
-              : null,
-          });
-          let childPlaySlot: { release(): void } | null = null;
-          try {
-            childPlaySlot = await governor.acquireChildSubmitSlot({
-              signal: abortSignal,
-            });
-            const childSubmitStartedAt = nowMs();
-            let started: {
-              workflowId?: string;
-              runId?: string;
-              status?: string;
-              mode?: string;
-              output?: unknown;
-              result?: unknown;
-              error?: unknown;
-              logs?: string[];
-              timings?: Array<{ phase: string; ms: number }>;
-            };
-            try {
-              started = await submitChildPlayThroughCoordinator({
-                req,
-                coordinatorBinding: cachedCoordinatorBinding,
-                makeRequestId,
-                coordinatorRequestHeaders,
-                allowInline: childExecutionDecision.strategy === 'inline',
-                body: {
-                  name: resolvedName,
-                  childIdempotencyKey: childInvocationId,
-                  input: isRecord(input) ? input : {},
-                  orgId: req.orgId,
-                  callbackUrl: req.callbackUrl,
-                  baseUrl: req.baseUrl,
-                  integrationMode: req.integrationMode ?? null,
-                  parentExecutorToken: req.executorToken,
-                  userEmail: req.userEmail ?? '',
-                  profile: 'workers_edge',
-                  manifest: childManifest,
-                  childPlayManifests: req.childPlayManifests ?? null,
-                  internalRunPlay: {
-                    rootRunId,
-                    parentRunId: req.runId,
-                    parentPlayName: req.playName,
-                    key: normalizedKey,
-                    // Per the lineage validator: ancestry tail must equal the
-                    // executor token's play name (the parent making this call).
-                    ancestryPlayIds,
-                    callDepth: nextDepth,
-                    // Cumulative lineage-global budget counters (incl. this
-                    // launch's play/descendant charges) so the child seeds its
-                    // budgets from the lineage total instead of resetting to 0 in
-                    // its isolate. Threading descendantCount in particular keeps
-                    // fan-out descendant accounting lineage-global, matching cjs.
-                    playCallCount: childGovernance.playCallCount,
-                    toolCallCount: childGovernance.toolCallCount,
-                    retryCount: childGovernance.retryCount,
-                    descendantCount: childGovernance.descendantCount,
-                    waterfallStepExecutions:
-                      childGovernance.waterfallStepExecutions,
-                    description:
-                      typeof options?.description === 'string'
-                        ? options.description
-                        : null,
-                  },
-                },
-              });
-            } catch (error) {
-              recordRunnerOperationalSpan(req, {
-                event: 'play.runtime.span',
-                phase: 'child_submit',
-                runId: req.runId,
-                parentRunId: req.runId,
-                playName: resolvedName,
-                graphHash: req.graphHash ?? null,
-                depth: nextDepth,
-                fanoutIndex: nextParentCalls - 1,
-                ms: nowMs() - childSubmitStartedAt,
-                status: 'failed',
-                errorCode: 'CHILD_SUBMIT_FAILED',
-              });
-              recordRunnerPerfTrace({
-                req,
-                phase: 'ctx_run_play.child_submit',
-                ms: nowMs() - childSubmitStartedAt,
-                extra: {
-                  status: 'failed',
-                  errorCode: 'CHILD_SUBMIT_FAILED',
-                  playName: resolvedName,
-                  key: normalizedKey,
-                  depth: nextDepth,
-                  fanoutIndex: nextParentCalls - 1,
-                  childIsDatasetBacked,
-                  childNeedsWorkflowScheduler,
-                },
-              });
-              throw error;
-            }
-            const workflowId = started.workflowId ?? started.runId;
-            if (!workflowId) {
-              const startedError = isRecord(started.error)
-                ? started.error
-                : { message: started.error };
-              const startedErrorMessage =
-                typeof startedError.message === 'string' &&
-                startedError.message.trim()
-                  ? startedError.message.trim()
-                  : null;
-              throw new Error(
-                startedErrorMessage ??
-                  `ctx.runPlay(${normalizedKey}) did not receive a child workflow id.`,
-              );
-            }
-            recordRunnerOperationalSpan(req, {
-              event: 'play.runtime.span',
-              phase: 'child_submit',
-              runId: req.runId,
-              parentRunId: req.runId,
-              childRunId: workflowId,
-              playName: resolvedName,
-              graphHash: req.graphHash ?? null,
-              depth: nextDepth,
-              fanoutIndex: nextParentCalls - 1,
-              ms: nowMs() - childSubmitStartedAt,
-              status: 'ok',
-            });
-            recordRunnerPerfTrace({
-              req,
-              phase: 'ctx_run_play.child_submit',
-              ms: nowMs() - childSubmitStartedAt,
-              extra: {
-                status: 'ok',
-                childRunId: workflowId,
-                startedStatus: started.status ?? null,
-                mode: started.mode ?? null,
-                coordinatorTimings: Array.isArray(started.timings)
-                  ? started.timings
-                  : null,
-                playName: resolvedName,
-                key: normalizedKey,
-                depth: nextDepth,
-                fanoutIndex: nextParentCalls - 1,
-                childIsDatasetBacked,
-                childNeedsWorkflowScheduler,
-              },
-            });
-            childPlaySlot?.release();
-            childPlaySlot = null;
-            const startedStatus = String(started.status ?? '').toLowerCase();
-            if (startedStatus === 'completed') {
-              emitEvent({
-                type: 'log',
-                level: 'info',
-                message: `Completed child play ${resolvedName} (${normalizedKey})`,
-                ts: nowMs(),
-              });
-              return hydrateChildPlayOutputDatasets({
-                req,
-                childRunId: workflowId,
-                childPlayName: resolvedName,
-                value: started.output ?? extractChildPlayOutput(started),
-              });
-            }
-            if (startedStatus === 'failed') {
-              const startedError = isRecord(started.error)
-                ? started.error
-                : { message: started.error };
-              const startedErrorMessage =
-                typeof startedError.message === 'string' &&
-                startedError.message.trim()
-                  ? startedError.message.trim()
-                  : `Child play ${resolvedName} (${workflowId}) failed.`;
-              throw new Error(startedErrorMessage);
-            }
-            const childWaitStartedAt = nowMs();
-            let waitResult: ChildPlayTerminalWaitResult;
-            const readCachedChildTerminalState =
-              cachedCoordinatorBinding?.readChildTerminalState?.bind(
-                cachedCoordinatorBinding,
-              );
-            try {
-              waitResult = await awaitChildTerminal({
-                parentRunId: req.runId,
-                // CF's WorkflowStep.waitForEvent generic signature is wider than
-                // the small structural shape ChildPlayAwait needs; bridge it the
-                // same way the inline implementation did.
-                workflowStep: workflowStep as unknown as
-                  | WorkflowStepLike
-                  | undefined,
-                workflowId,
-                playName: resolvedName,
-                key: normalizedKey,
-                timeoutMs: Math.max(
-                  1_000,
-                  Math.min(options?.timeoutMs ?? 5 * 60_000, 30 * 60_000),
-                ),
-                coordinator: {
-                  readRunTerminalState: (runId, timeoutMs) =>
-                    readDurableChildRunTerminalState({
-                      baseUrl: req.baseUrl,
-                      executorToken: req.executorToken,
-                      parentRunId: req.runId,
-                      childRunId: runId,
-                      childPlayName: resolvedName,
-                      timeoutMs,
-                    }),
-                  ...(readCachedChildTerminalState
-                    ? {
-                        readChildTerminalState: (
-                          parentRunId: string,
-                          eventKey: string,
-                          timeoutMs?: number,
-                        ) =>
-                          readCachedChildTerminalState(
-                            parentRunId,
-                            eventKey,
-                            timeoutMs,
-                          ),
-                      }
-                    : {}),
-                },
-                now: nowMs,
-                hashJson,
-              });
-            } catch (error) {
-              recordRunnerOperationalSpan(req, {
-                event: 'play.runtime.span',
-                phase: 'child_wait',
-                runId: req.runId,
-                parentRunId: req.runId,
-                childRunId: workflowId,
-                playName: resolvedName,
-                graphHash: req.graphHash ?? null,
-                depth: nextDepth,
-                fanoutIndex: nextParentCalls - 1,
-                ms: nowMs() - childWaitStartedAt,
-                status: 'failed',
-                errorCode: 'CHILD_WAIT_FAILED',
-              });
-              recordRunnerPerfTrace({
-                req,
-                phase: 'ctx_run_play.child_wait',
-                ms: nowMs() - childWaitStartedAt,
-                extra: {
-                  status: 'failed',
-                  errorCode: 'CHILD_WAIT_FAILED',
-                  childRunId: workflowId,
-                  playName: resolvedName,
-                  key: normalizedKey,
-                  depth: nextDepth,
-                  fanoutIndex: nextParentCalls - 1,
-                  childIsDatasetBacked,
-                  childNeedsWorkflowScheduler,
-                },
-              });
-              throw error;
-            }
-            recordRunnerOperationalSpan(req, {
-              event: 'play.runtime.span',
-              phase: 'child_wait',
-              runId: req.runId,
-              parentRunId: req.runId,
-              childRunId: workflowId,
-              playName: resolvedName,
-              graphHash: req.graphHash ?? null,
-              depth: nextDepth,
-              fanoutIndex: nextParentCalls - 1,
-              ms: nowMs() - childWaitStartedAt,
-              status: 'ok',
-              waitSource: waitResult.source,
-              waitAttempts: waitResult.attempts ?? null,
-              reportedWaitMs: waitResult.waitMs,
-            });
-            recordRunnerPerfTrace({
-              req,
-              phase: 'ctx_run_play.child_wait',
-              ms: nowMs() - childWaitStartedAt,
-              extra: {
-                status: 'ok',
-                childRunId: workflowId,
-                playName: resolvedName,
-                key: normalizedKey,
-                depth: nextDepth,
-                fanoutIndex: nextParentCalls - 1,
-                childIsDatasetBacked,
-                childNeedsWorkflowScheduler,
-                waitSource: waitResult.source,
-                waitAttempts: waitResult.attempts ?? null,
-                reportedWaitMs: waitResult.waitMs,
-              },
-            });
-            emitEvent({
-              type: 'log',
-              level: 'info',
-              message: `Completed child play ${resolvedName} (${normalizedKey})`,
-              ts: nowMs(),
-            });
-            return hydrateChildPlayOutputDatasets({
-              req,
-              childRunId: workflowId,
-              childPlayName: resolvedName,
-              value: waitResult.output,
-            });
-          } finally {
-            childPlaySlot?.release();
-          }
-        },
+      throw new Error(
+        `CTX_RUN_PLAY_INLINE_ONLY: ctx.runPlay("${resolvedName}") is unavailable on the retired workers_edge runtime. Run this play on the current runtime, where resolved scalar children compose inline.`,
       );
     },
     async fetch(
@@ -7778,7 +6986,10 @@ async function executeRunRequest(
   let ledgerFlushQueueDepth = 0;
 
   const appendRunLogLine = (line: string) => {
-    const trimmed = redactSecretsFromLogString(line.trim());
+    const trimmed = redactSecretsFromLogString(line.trim()).slice(
+      0,
+      MAX_LEDGER_LOG_LINE_LENGTH,
+    );
     if (!trimmed) return;
     workBudgetMeter.count('log');
     totalEmittedLogLines += 1;
@@ -7861,17 +7072,27 @@ async function executeRunRequest(
     pendingLedgerEvents = [];
 
     if (pendingRunLogLines.length > 0) {
-      events.push({
-        type: 'log.appended',
-        runId: req.runId,
-        source: 'worker',
-        occurredAt,
-        lines: pendingRunLogLines,
-        // Positional cursor: pendingRunLogLines always holds the LAST
-        // pending lines emitted on this channel, so the offset of its first
-        // line is total-emitted minus pending length.
-        channelOffset: totalEmittedLogLines - pendingRunLogLines.length,
-      });
+      const channelOffset = totalEmittedLogLines - pendingRunLogLines.length;
+      for (
+        let start = 0;
+        start < pendingRunLogLines.length;
+        start += MAX_LEDGER_LOG_LINES_PER_EVENT
+      ) {
+        events.push({
+          type: 'log.appended',
+          runId: req.runId,
+          source: 'worker',
+          occurredAt,
+          lines: pendingRunLogLines.slice(
+            start,
+            start + MAX_LEDGER_LOG_LINES_PER_EVENT,
+          ),
+          // Positional cursor: pendingRunLogLines always holds the LAST
+          // pending lines emitted on this channel, so the offset of its first
+          // line is total-emitted minus pending length.
+          channelOffset: channelOffset + start,
+        });
+      }
       pendingRunLogLines = [];
     }
 
@@ -7956,19 +7177,26 @@ async function executeRunRequest(
     ledgerFlushInFlight = ledgerFlushInFlight
       .catch(() => undefined)
       .then(async () => {
-        try {
-          await postRuntimeApi(req.baseUrl, req.executorToken, {
-            action: 'append_run_events',
-            playId: req.runId,
-            events,
-          });
-        } catch {
-          pendingLedgerEvents = [...events, ...pendingLedgerEvents];
-          throw new Error('runtime run-ledger append failed');
-        } finally {
-          ledgerFlushQueueDepth = Math.max(0, ledgerFlushQueueDepth - 1);
+        const batches = partitionWorkerLedgerEvents(events);
+        for (let index = 0; index < batches.length; index += 1) {
+          try {
+            await postRuntimeApi(req.baseUrl, req.executorToken, {
+              action: 'append_run_events',
+              playId: req.runId,
+              events: batches[index]!,
+            });
+          } catch {
+            pendingLedgerEvents = [
+              ...batches.slice(index).flat(),
+              ...pendingLedgerEvents,
+            ];
+            throw new Error('runtime run-ledger append failed');
+          }
         }
       })
+      .finally(() => {
+        ledgerFlushQueueDepth = Math.max(0, ledgerFlushQueueDepth - 1);
+      })
       .catch(() => undefined);
     return force ? ledgerFlushInFlight : Promise.resolve();
   };
@@ -7976,9 +7204,7 @@ async function executeRunRequest(
   const flushTerminalLedgerEvents = async (
     terminalEvent: PlayRunLedgerEvent,
   ): Promise<void> => {
-    const shouldPersistTerminalLedger =
-      options?.persistResultDatasets === true ||
-      Boolean(req.playCallGovernance);
+    const shouldPersistTerminalLedger = options?.persistResultDatasets === true;
     if (!shouldPersistTerminalLedger) return;
     await ledgerFlushInFlight;
     const now = nowMs();
@@ -7988,15 +7214,21 @@ async function executeRunRequest(
     ]);
     const events = [...drainPendingLedgerEvents(now), terminalEvent];
     if (events.length === 0) return;
-    try {
-      await postRuntimeApi(req.baseUrl, req.executorToken, {
-        action: 'append_run_events',
-        playId: req.runId,
-        events,
-      });
-    } catch (error) {
-      pendingLedgerEvents = [...events, ...pendingLedgerEvents];
-      throw error;
+    const batches = partitionWorkerLedgerEvents(events);
+    for (let index = 0; index < batches.length; index += 1) {
+      try {
+        await postRuntimeApi(req.baseUrl, req.executorToken, {
+          action: 'append_run_events',
+          playId: req.runId,
+          events: batches[index]!,
+        });
+      } catch (error) {
+        pendingLedgerEvents = [
+          ...batches.slice(index).flat(),
+          ...pendingLedgerEvents,
+        ];
+        throw error;
+      }
     }
   };
 
@@ -8177,46 +7409,6 @@ async function executeRunRequest(
         ms: nowMs() - resultDatasetStartedAt,
       });
     };
-    let parentSignalPromise: Promise<void> | null = null;
-    const startParentTerminalSignal = (): Promise<void> => {
-      if (!parentSignalPromise) {
-        const parentSignalStartedAt = nowMs();
-        parentSignalPromise = signalParentPlayTerminal({
-          req,
-          status: 'completed',
-          result: req.playCallGovernance ? serializedResult : terminalResult,
-        })
-          .catch((error) => {
-            void runnerTelemetry
-              .child({
-                context: {
-                  runId: req.runId,
-                  orgId: req.orgId,
-                  playName: req.playName,
-                },
-              })
-              .error(
-                'runner.parent_completion_signal.failed',
-                error,
-                undefined,
-                {
-                  tag: '[play-harness] non-fatal parent completion signal failed',
-                },
-              );
-          })
-          .finally(() => {
-            recordRunnerPerfTrace({
-              req,
-              phase: 'runner.parent_terminal_signal',
-              ms: nowMs() - parentSignalStartedAt,
-            });
-          });
-      }
-      return parentSignalPromise;
-    };
-    if (req.playCallGovernance && !options?.persistResultDatasets) {
-      await persistProjectedResultDatasets();
-    }
     await releaseRuntimeLeasesOnSettlement({
       req,
       leasedSheetNamespaces,
@@ -8259,7 +7451,6 @@ async function executeRunRequest(
         ms: nowMs() - terminalUpdateStartedAt,
       });
 
-      const parentSignal = startParentTerminalSignal();
       if (!capped) {
         const billingStartedAt = nowMs();
         const billingPromise = finalizeWorkerComputeBilling({
@@ -8292,23 +7483,7 @@ async function executeRunRequest(
           await nonBlockingBillingPromise;
         }
       }
-      await parentSignal;
-    } else if (req.playCallGovernance) {
-      const childTerminalStartedAt = nowMs();
-      await flushTerminalLedgerEvents({
-        type: 'run.completed',
-        runId: req.runId,
-        source: 'worker',
-        occurredAt: nowMs(),
-        result: terminalResult,
-      });
-      recordRunnerPerfTrace({
-        req,
-        phase: 'runner.child_terminal_ledger_append',
-        ms: nowMs() - childTerminalStartedAt,
-      });
     }
-    await startParentTerminalSignal();
     recordRunnerPerfTrace({
       req,
       phase: 'runner.execute_total',
@@ -8364,7 +7539,7 @@ async function executeRunRequest(
         ? `${message} ${receiptSalvageFailureSuffix(salvage)}`
         : message;
     const terminalLedgerMessage = redactSecretsFromLogString(terminalMessage);
-    if (options?.persistResultDatasets || req.playCallGovernance) {
+    if (options?.persistResultDatasets) {
       appendRunLogLine(
         `${aborted ? '[cancelled]' : '[error]'} ${terminalLedgerMessage}`,
       );
@@ -8398,13 +7573,9 @@ async function executeRunRequest(
       });
       recordRunnerPerfTrace({
         req,
-        phase: req.playCallGovernance
-          ? aborted
-            ? 'runner.child_terminal_ledger_append_cancelled'
-            : 'runner.child_terminal_ledger_append_failed'
-          : aborted
-            ? 'runner.terminal_ledger_append_cancelled'
-            : 'runner.terminal_ledger_append_failed',
+        phase: aborted
+          ? 'runner.terminal_ledger_append_cancelled'
+          : 'runner.terminal_ledger_append_failed',
         ms: nowMs() - terminalUpdateStartedAt,
         extra: {
           errorCode: failure.code,
@@ -8445,11 +7616,6 @@ async function executeRunRequest(
           });
       }
     }
-    await signalParentPlayTerminal({
-      req,
-      status: aborted ? 'cancelled' : 'failed',
-      error: terminalMessage,
-    }).catch(() => null);
     recordRunnerPerfTrace({
       req,
       phase: aborted ? 'runner.execute_cancelled' : 'runner.execute_failed',
@@ -8600,12 +7766,6 @@ function runRequestFromWorkflowParams(
     executionPlan: isExecutionPlan(params.executionPlan)
       ? (params.executionPlan as ExecutionPlan)
       : null,
-    childPlayManifests: isRecord(params.childPlayManifests)
-      ? (params.childPlayManifests as PlayRuntimeManifestMap)
-      : null,
-    playCallGovernance: isPlayCallGovernanceSnapshot(params.playCallGovernance)
-      ? params.playCallGovernance
-      : null,
     preloadedDbSessions: Array.isArray(params.preloadedDbSessions)
       ? (params.preloadedDbSessions as PreloadedRuntimeDbSession[])
       : null,
@@ -8642,22 +7802,6 @@ function isExecutionPlan(value: unknown): value is ExecutionPlan {
   );
 }
 
-function isPlayCallGovernanceSnapshot(
-  value: unknown,
-): value is PlayCallGovernanceSnapshot {
-  return (
-    isRecord(value) &&
-    typeof value.rootRunId === 'string' &&
-    typeof value.parentRunId === 'string' &&
-    typeof value.parentPlayName === 'string' &&
-    typeof value.key === 'string' &&
-    Array.isArray(value.ancestryPlayIds) &&
-    value.ancestryPlayIds.every((entry) => typeof entry === 'string') &&
-    typeof value.callDepth === 'number' &&
-    Number.isFinite(value.callDepth)
-  );
-}
-
 async function persistResultDatasets(
   req: RunRequest,
   resultDatasets: ProjectedResultDatasetHandle[],
@@ -8983,7 +8127,7 @@ export class TenantWorkflow extends WorkflowEntrypoint<
         },
         step,
         {
-          persistResultDatasets: !req.playCallGovernance,
+          persistResultDatasets: true,
           abortController,
           waitUntil: (promise) => this.ctx.waitUntil(promise),
         },