deepline 0.1.26 → 0.1.27

package/dist/cli/index.js

@@ -266,7 +266,7 @@ function saveProjectDeeplineEnvValues(baseUrl, values, startDir = projectEnvStar
 }
 
 // src/version.ts
-var SDK_VERSION = "0.1.26";
+var SDK_VERSION = "0.1.27";
 var SDK_API_CONTRACT = "2026-05-runs-v2";
 
 // ../shared_libs/play-runtime/coordinator-headers.ts

package/dist/cli/index.mjs

@@ -243,7 +243,7 @@ function saveProjectDeeplineEnvValues(baseUrl, values, startDir = projectEnvStar
 }
 
 // src/version.ts
-var SDK_VERSION = "0.1.26";
+var SDK_VERSION = "0.1.27";
 var SDK_API_CONTRACT = "2026-05-runs-v2";
 
 // ../shared_libs/play-runtime/coordinator-headers.ts

package/dist/index.d.mts

@@ -1401,7 +1401,7 @@ declare class DeeplineClient {
     }>;
 }
 
-declare const SDK_VERSION = "0.1.26";
+declare const SDK_VERSION = "0.1.27";
 declare const SDK_API_CONTRACT = "2026-05-runs-v2";
 
 /**

package/dist/index.d.ts

@@ -1401,7 +1401,7 @@ declare class DeeplineClient {
     }>;
 }
 
-declare const SDK_VERSION = "0.1.26";
+declare const SDK_VERSION = "0.1.27";
 declare const SDK_API_CONTRACT = "2026-05-runs-v2";
 
 /**

package/dist/index.js

@@ -241,7 +241,7 @@ function resolveConfig(options) {
 }
 
 // src/version.ts
-var SDK_VERSION = "0.1.26";
+var SDK_VERSION = "0.1.27";
 var SDK_API_CONTRACT = "2026-05-runs-v2";
 
 // ../shared_libs/play-runtime/coordinator-headers.ts

package/dist/index.mjs

@@ -195,7 +195,7 @@ function resolveConfig(options) {
 }
 
 // src/version.ts
-var SDK_VERSION = "0.1.26";
+var SDK_VERSION = "0.1.27";
 var SDK_API_CONTRACT = "2026-05-runs-v2";
 
 // ../shared_libs/play-runtime/coordinator-headers.ts

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

@@ -232,7 +232,7 @@ interface CoordinatorEnv {
   /**
    * Service binding to the long-lived Play Harness Worker
    * (apps/play-harness-worker). Provides typed RPC access to leaf-level
-   * helpers (zod validation, runtime-API HTTP forwarder, …) that we
+   * helpers (runtime-API HTTP forwarder, Neon dataset IO, …) that we
    * deliberately keep OUT of every per-graphHash play bundle.
    *
    * Optional: when missing (e.g. an older deploy that hasn't been wired
@@ -547,10 +547,10 @@ const WORKFLOW_POOL_READY_POLL_MS = 250;
 const WORKFLOW_POOL_REFILL_ON_MISS_TIMEOUT_MS = 2_500;
 const WORKFLOW_POOL_REFILL_ON_MISS_MIN_AVAILABLE = 4;
 const WORKFLOW_POOL_CONTROL_TIMEOUT_MS = 750;
+const WORKFLOW_POOL_START_ACK_TIMEOUT_MS = 750;
+const WORKFLOW_POOL_START_ACK_POLL_MS = 25;
 const SUBMIT_INITIAL_STATE_MAX_WAIT_MS = 0;
 const SUBMIT_INITIAL_STATE_POLL_MS = 50;
-const WORKFLOW_POOL_DISABLED_REASON =
-  'Cloudflare Workflows start runs directly; waitForEvent is reserved for real durable external waits.';
 function buildDynamicWorkflowMetadata(
   params: PlayWorkflowParams,
 ): DynamicWorkflowMetadata {
@@ -623,7 +623,7 @@ function readWorkflowTraceContext(event: unknown): {
 }
 
 function workflowPoolEnabled(): boolean {
-  return false;
+  return WORKFLOW_POOL_TARGET_SIZE > 0;
 }
 
 function workflowPoolTargetSize(): number {
@@ -889,8 +889,33 @@ async function mapRunToWorkflowInstance(input: {
   env: CoordinatorEnv;
   runId: string;
   instanceId: string;
-}): Promise<void> {
-  await callWorkflowPool(input.env, '/pool-map-run', {
+  started?: boolean;
+}): Promise<boolean> {
+  const body = await callWorkflowPool<{ mapped?: unknown }>(
+    input.env,
+    '/pool-map-run',
+    {
+      method: 'POST',
+      body: JSON.stringify({
+        runId: input.runId,
+        instanceId: input.instanceId,
+        started: input.started === true,
+        version: WORKFLOW_POOL_PROTOCOL_VERSION,
+      }),
+    },
+  );
+  return body.mapped !== false;
+}
+
+async function blockWorkflowPoolRun(input: {
+  env: CoordinatorEnv;
+  runId: string;
+  instanceId: string;
+}): Promise<{ blocked: boolean; started: boolean }> {
+  const body = await callWorkflowPool<{
+    blocked?: unknown;
+    started?: unknown;
+  }>(input.env, '/pool-block-run', {
     method: 'POST',
     body: JSON.stringify({
       runId: input.runId,
@@ -898,6 +923,82 @@ async function mapRunToWorkflowInstance(input: {
       version: WORKFLOW_POOL_PROTOCOL_VERSION,
     }),
   });
+  return {
+    blocked: body.blocked === true,
+    started: body.started === true,
+  };
+}
+
+async function readWorkflowPoolRunMapping(input: {
+  env: CoordinatorEnv;
+  runId: string;
+}): Promise<{ instanceId: string | null; startedAt: number | null }> {
+  const body = await callWorkflowPool<{
+    instanceId?: unknown;
+    startedAt?: unknown;
+  }>(
+    input.env,
+    `/pool-resolve-run?runId=${encodeURIComponent(input.runId)}&version=${encodeURIComponent(
+      WORKFLOW_POOL_PROTOCOL_VERSION,
+    )}`,
+  ).catch(() => ({ instanceId: null, startedAt: null }));
+  return {
+    instanceId:
+      typeof body.instanceId === 'string' && body.instanceId
+        ? body.instanceId
+        : null,
+    startedAt:
+      typeof body.startedAt === 'number' && Number.isFinite(body.startedAt)
+        ? body.startedAt
+        : null,
+  };
+}
+
+async function waitForWorkflowPoolStartAck(input: {
+  env: CoordinatorEnv;
+  runId: string;
+  instanceId: string;
+  timeoutMs: number;
+}): Promise<{
+  acknowledged: boolean;
+  ms: number;
+  polls: number;
+  startedAt: number | null;
+  mappedInstanceId: string | null;
+}> {
+  const startedAt = Date.now();
+  let polls = 0;
+  let latestMapping: { instanceId: string | null; startedAt: number | null } = {
+    instanceId: null,
+    startedAt: null,
+  };
+  while (Date.now() - startedAt < input.timeoutMs) {
+    polls += 1;
+    latestMapping = await readWorkflowPoolRunMapping({
+      env: input.env,
+      runId: input.runId,
+    });
+    if (
+      latestMapping.instanceId === input.instanceId &&
+      latestMapping.startedAt !== null
+    ) {
+      return {
+        acknowledged: true,
+        ms: Date.now() - startedAt,
+        polls,
+        startedAt: latestMapping.startedAt,
+        mappedInstanceId: latestMapping.instanceId,
+      };
+    }
+    await sleep(WORKFLOW_POOL_START_ACK_POLL_MS);
+  }
+  return {
+    acknowledged: false,
+    ms: Date.now() - startedAt,
+    polls,
+    startedAt: latestMapping.startedAt,
+    mappedInstanceId: latestMapping.instanceId,
+  };
 }
 
 async function resolveWorkflowInstanceIdForRun(
@@ -907,15 +1008,8 @@ async function resolveWorkflowInstanceIdForRun(
   if (!workflowPoolEnabled()) {
     return workflowInstanceId(runId);
   }
-  const body = await callWorkflowPool<{ instanceId?: unknown }>(
-    env,
-    `/pool-resolve-run?runId=${encodeURIComponent(runId)}&version=${encodeURIComponent(
-      WORKFLOW_POOL_PROTOCOL_VERSION,
-    )}`,
-  ).catch(() => ({ instanceId: null }));
-  return typeof body.instanceId === 'string' && body.instanceId
-    ? body.instanceId
-    : workflowInstanceId(runId);
+  const mapping = await readWorkflowPoolRunMapping({ env, runId });
+  return mapping.instanceId ? mapping.instanceId : workflowInstanceId(runId);
 }
 
 async function clearWorkflowPool(env: CoordinatorEnv): Promise<number> {
@@ -927,7 +1021,10 @@ async function clearWorkflowPool(env: CoordinatorEnv): Promise<number> {
   );
   await Promise.all(
     entries.map(async (entry) => {
-      const instance = await env.PLAY_WORKFLOW.get(entry.id);
+      const instance = await getWorkflowPoolInstance(env, entry.id);
+      if (!instance) {
+        return;
+      }
       try {
         await instance.terminate().catch(() => undefined);
       } finally {
@@ -942,6 +1039,27 @@ function workflowStatusName(status: InstanceStatus | null): string {
   return typeof status?.status === 'string' ? status.status : 'unknown';
 }
 
+function isWorkflowInstanceNotFoundError(error: unknown): boolean {
+  const message = error instanceof Error ? error.message : String(error);
+  return /not[ _]found|not_found|does not exist|no such instance|404/i.test(
+    message,
+  );
+}
+
+async function getWorkflowPoolInstance(
+  env: CoordinatorEnv,
+  instanceId: string,
+): Promise<WorkflowInstance | null> {
+  try {
+    return await env.PLAY_WORKFLOW.get(instanceId);
+  } catch (error) {
+    if (isWorkflowInstanceNotFoundError(error)) {
+      return null;
+    }
+    throw error;
+  }
+}
+
 function workflowPoolStatusIsReady(statusName: string): boolean {
   // This is only a liveness guard. Readiness itself comes from the pooled
   // Workflow calling /pool-ready after waitForEvent("play_start") has been
@@ -1024,7 +1142,11 @@ async function refillWorkflowPoolOnce(
   const promotedIds: string[] = [];
   const removedIds: string[] = [];
   for (const entry of warmingEntries) {
-    const instance = await env.PLAY_WORKFLOW.get(entry.id);
+    const instance = await getWorkflowPoolInstance(env, entry.id);
+    if (!instance) {
+      removedIds.push(entry.id);
+      continue;
+    }
     try {
       if (entry.state === 'ready' && entry.readyAt !== null) {
         promotedIds.push(entry.id);
@@ -1251,7 +1373,21 @@ async function submitViaPooledWorkflow(input: {
     return null;
   }
 
-  const instance = await input.env.PLAY_WORKFLOW.get(pooledInstanceId);
+  const instance = await getWorkflowPoolInstance(input.env, pooledInstanceId);
+  if (!instance) {
+    await blockWorkflowPoolRun({
+      env: input.env,
+      runId: input.params.runId,
+      instanceId: pooledInstanceId,
+    }).catch(() => undefined);
+    input.recordSubmitTiming({
+      phase: 'coordinator.workflow_pool_ready_check',
+      ms: Date.now() - leaseStartedAt,
+      graphHash: input.params.graphHash ?? null,
+      extra: { instanceId: pooledInstanceId, status: 'missing' },
+    });
+    return null;
+  }
   const readyCheckStartedAt = Date.now();
   const status = await instance.status().catch(() => null);
   const statusName = workflowStatusName(status);
@@ -1262,6 +1398,11 @@ async function submitViaPooledWorkflow(input: {
     extra: { instanceId: pooledInstanceId, status: statusName },
   });
   if (!workflowPoolStatusIsReady(statusName)) {
+    await blockWorkflowPoolRun({
+      env: input.env,
+      runId: input.params.runId,
+      instanceId: pooledInstanceId,
+    }).catch(() => undefined);
     await instance.terminate().catch(() => undefined);
     disposeRpcStub(instance);
     return null;
@@ -1273,6 +1414,11 @@ async function submitViaPooledWorkflow(input: {
       payload: buildDispatcherEnvelope(input.params),
     });
   } catch (error) {
+    await blockWorkflowPoolRun({
+      env: input.env,
+      runId: input.params.runId,
+      instanceId: pooledInstanceId,
+    }).catch(() => undefined);
     disposeRpcStub(instance);
     console.warn('[coordinator.workflow_pool] sendEvent failed; falling back', {
       runId: input.params.runId,
@@ -1287,7 +1433,63 @@ async function submitViaPooledWorkflow(input: {
     graphHash: input.params.graphHash ?? null,
     extra: { instanceId: pooledInstanceId },
   });
-  return instance;
+  const ack = await waitForWorkflowPoolStartAck({
+    env: input.env,
+    runId: input.params.runId,
+    instanceId: pooledInstanceId,
+    timeoutMs: WORKFLOW_POOL_START_ACK_TIMEOUT_MS,
+  });
+  if (ack.acknowledged) {
+    input.recordSubmitTiming({
+      phase: 'coordinator.workflow_pool_start_ack',
+      ms: ack.ms,
+      graphHash: input.params.graphHash ?? null,
+      extra: {
+        acknowledged: true,
+        instanceId: pooledInstanceId,
+        polls: ack.polls,
+        startedAt: ack.startedAt,
+      },
+    });
+    return instance;
+  }
+
+  const blockStartedAt = Date.now();
+  const block = await blockWorkflowPoolRun({
+    env: input.env,
+    runId: input.params.runId,
+    instanceId: pooledInstanceId,
+  }).catch(() => ({ blocked: false, started: false }));
+  input.recordSubmitTiming({
+    phase: 'coordinator.workflow_pool_start_ack',
+    ms: ack.ms,
+    graphHash: input.params.graphHash ?? null,
+    extra: {
+      acknowledged: block.started,
+      instanceId: pooledInstanceId,
+      polls: ack.polls,
+      startedAt: ack.startedAt,
+      mappedInstanceId: ack.mappedInstanceId,
+      blocked: block.blocked,
+      blockMs: Date.now() - blockStartedAt,
+    },
+  });
+  if (block.started) {
+    return instance;
+  }
+  await instance.terminate().catch(() => undefined);
+  disposeRpcStub(instance);
+  input.recordSubmitTiming({
+    phase: 'coordinator.workflow_pool_fallback',
+    ms: Date.now() - sendStartedAt,
+    graphHash: input.params.graphHash ?? null,
+    extra: {
+      reason: 'start_ack_timeout',
+      instanceId: pooledInstanceId,
+      ackTimeoutMs: WORKFLOW_POOL_START_ACK_TIMEOUT_MS,
+    },
+  });
+  return null;
 }
 
 function readWorkflowPayload(event: unknown): Record<string, unknown> | null {
@@ -2186,9 +2388,35 @@ export class DynamicWorkflow extends WorkflowEntrypoint<
       dispatchedEvent = {
         payload: startEvent.payload,
         timestamp: startEvent.timestamp,
-        instanceId: workflowEvent.instanceId,
+        instanceId: workflowEvent.instanceId ?? pooledPayload.poolId,
       };
       const dispatchedTrace = readWorkflowTraceContext(dispatchedEvent);
+      const mapped = await mapRunToWorkflowInstance({
+        env: this.env,
+        runId: dispatchedTrace.runId,
+        instanceId: pooledPayload.poolId,
+        started: true,
+      }).catch((error) => {
+        console.warn('[coordinator.workflow_pool] start ack failed', {
+          poolId: pooledPayload.poolId,
+          runId: dispatchedTrace.runId,
+          message: error instanceof Error ? error.message : String(error),
+        });
+        return false;
+      });
+      if (!mapped) {
+        trace({
+          runId: dispatchedTrace.runId,
+          phase: 'coordinator.workflow_pool_start_blocked',
+          ms: 0,
+          graphHash: dispatchedTrace.graphHash,
+          extra: {
+            instanceId: pooledPayload.poolId,
+            eventType: startEvent.type,
+          },
+        });
+        return { ok: false, blocked: true, runId: dispatchedTrace.runId };
+      }
       const eventDeliveryMs = Math.max(
         0,
         Date.now() - startEvent.timestamp.getTime(),
@@ -2472,7 +2700,15 @@ const coordinatorEntrypoint = {
       const entries = await listWorkflowPoolEntries(env);
       const detailed = [];
       for (const entry of entries) {
-        const instance = await env.PLAY_WORKFLOW.get(entry.id);
+        const instance = await getWorkflowPoolInstance(env, entry.id);
+        if (!instance) {
+          detailed.push({
+            ...entry,
+            status: 'missing',
+            mappedStatus: 'failed',
+          });
+          continue;
+        }
         try {
           const status = await instance.status().catch(() => null);
           detailed.push({
@@ -2536,6 +2772,14 @@ const coordinatorEntrypoint = {
   async tail(events: unknown[], env: CoordinatorEnv): Promise<void> {
     await flushTailRunLogs(events, env);
   },
+  async scheduled(
+    _controller: unknown,
+    env: CoordinatorEnv,
+    ctx?: ExecutionContext,
+  ): Promise<void> {
+    if (!workflowPoolEnabled()) return;
+    ctx?.waitUntil(refillWorkflowPool(env).catch(() => undefined));
+  },
 };
 
 export default coordinatorEntrypoint;
@@ -2698,36 +2942,100 @@ async function handleWorkflowRoute(input: {
           'Start apps/play-harness-worker before the coordinator or fix wrangler.toml services.',
       );
     }
+    const preloadedDbSessions = Array.isArray(params.preloadedDbSessions)
+      ? params.preloadedDbSessions
+      : [];
+    if (preloadedDbSessions.length > 0 && params.executorToken) {
+      const prewarmStartedAt = Date.now();
+      recordSubmitTiming({
+        phase: 'coordinator.harness_prewarm_postgres_start',
+        ms: 0,
+        graphHash: params.graphHash ?? null,
+        extra: { sessions: preloadedDbSessions.length },
+      });
+      const prewarmPromise = env.HARNESS.prewarmPostgresSessions({
+        executorToken: params.executorToken,
+        sessions: preloadedDbSessions,
+      })
+        .then((result) => {
+          recordSubmitTiming({
+            phase: 'coordinator.harness_prewarm_postgres',
+            ms: Date.now() - prewarmStartedAt,
+            graphHash: params.graphHash ?? null,
+            extra: {
+              status: 'ok',
+              sessions: result.sessions,
+            },
+          });
+        })
+        .catch((error: unknown) => {
+          recordSubmitTiming({
+            phase: 'coordinator.harness_prewarm_postgres',
+            ms: Date.now() - prewarmStartedAt,
+            graphHash: params.graphHash ?? null,
+            extra: {
+              status: 'failed',
+              sessions: preloadedDbSessions.length,
+              error: error instanceof Error ? error.message : String(error),
+            },
+          });
+        });
+      input.ctx?.waitUntil(prewarmPromise);
+    }
     let instance: WorkflowInstance | null = null;
     try {
-      const dispatchStartedAt = Date.now();
+      const statusEventStartedAt = Date.now();
+      await appendCoordinatorRunEvent(env, {
+        runId: submittedRunId,
+        type: 'status',
+        status: 'running',
+        ts: Date.now(),
+      });
       recordSubmitTiming({
-        phase: 'coordinator.workflow_pool_attempt',
-        ms: 0,
+        phase: 'coordinator.submit_status_event',
+        ms: Date.now() - statusEventStartedAt,
         graphHash: params.graphHash ?? null,
-        extra: {
-          usedPool: false,
-          disabled: true,
-          reason: WORKFLOW_POOL_DISABLED_REASON,
-        },
       });
-      const createStartedAt = Date.now();
-      instance = await createDynamicWorkflowInstance({
+      const dispatchStartedAt = Date.now();
+      const poolAttemptStartedAt = Date.now();
+      instance = await submitViaPooledWorkflow({
         env,
-        id: defaultInstanceId,
         params,
+        recordSubmitTiming,
       });
       recordSubmitTiming({
-        phase: 'coordinator.workflow_create',
-        ms: Date.now() - createStartedAt,
+        phase: 'coordinator.workflow_pool_attempt',
+        ms: Date.now() - poolAttemptStartedAt,
         graphHash: params.graphHash ?? null,
-        extra: { instanceId: instance.id },
+        extra: {
+          usedPool: Boolean(instance),
+          enabled: workflowPoolEnabled(),
+        },
       });
+      if (!instance) {
+        const createStartedAt = Date.now();
+        instance = await createDynamicWorkflowInstance({
+          env,
+          id: defaultInstanceId,
+          params,
+        });
+        recordSubmitTiming({
+          phase: 'coordinator.workflow_create',
+          ms: Date.now() - createStartedAt,
+          graphHash: params.graphHash ?? null,
+          extra: { instanceId: instance.id },
+        });
+      }
       recordSubmitTiming({
         phase: 'coordinator.dispatch_workflow',
         ms: Date.now() - dispatchStartedAt,
         graphHash: params.graphHash ?? null,
-        extra: { startMode: 'direct_workflow_create' },
+        extra: {
+          startMode:
+            instance.id === defaultInstanceId
+              ? 'direct_workflow_create'
+              : 'pooled_workflow_start_event',
+        },
       });
       const initialWaitMsRaw = Number(
         new URL(request.url).searchParams.get('initialWaitMs') ?? '0',
@@ -2761,6 +3069,9 @@ async function handleWorkflowRoute(input: {
         ms: totalMs,
         graphHash: params.graphHash ?? null,
       });
+      if (workflowPoolEnabled() && instance.id === defaultInstanceId) {
+        input.ctx?.waitUntil(refillWorkflowPool(env).catch(() => undefined));
+      }
       return Response.json({
         runId,
         status: 'submitted',
@@ -3016,11 +3327,19 @@ async function handleWorkflowRoute(input: {
       afterSeq,
       timeoutMs: waitMs,
     }).catch(() => null);
+    const rawEvents = eventResult?.events ?? [];
+    const terminalEventIndex = rawEvents.findIndex(
+      (event) => event.type === 'terminal',
+    );
+    const events =
+      terminalEventIndex >= 0
+        ? rawEvents.slice(0, terminalEventIndex + 1)
+        : rawEvents;
     const coordinatorTrace =
-      includeTrace && eventResult?.events.length
+      includeTrace && events.length
         ? await listCoordinatorPerfTrace(env, runId).catch(() => [])
         : [];
-    const terminalEvent = eventResult?.events.find(
+    const terminalEvent = events.find(
       (event): event is Extract<CoordinatorRunEvent, { type: 'terminal' }> =>
         event.type === 'terminal',
     );
@@ -3036,7 +3355,7 @@ async function handleWorkflowRoute(input: {
         completedAt: terminalEvent.ts,
         liveLogs: sanitizeLiveLogLines(terminalEvent.liveLogs),
         liveNodeProgress: terminalEvent.liveNodeProgress ?? null,
-        events: eventResult?.events ?? [],
+        events,
         latestSeq: eventResult?.latestSeq ?? afterSeq,
         wait: null,
         coordinatorObserve: {
@@ -3052,7 +3371,7 @@ async function handleWorkflowRoute(input: {
     return Response.json({
       runId,
       status: 'running',
-      events: eventResult?.events ?? [],
+      events,
       latestSeq: eventResult?.latestSeq ?? afterSeq,
       wait: null,
       coordinatorObserve: {
@@ -3250,7 +3569,7 @@ function stableHash(value: string): string {
   return (hash >>> 0).toString(36);
 }
 
-const DYNAMIC_PLAY_WORKER_HARNESS_VERSION = 'h11-full-row-dataset-handles';
+const DYNAMIC_PLAY_WORKER_HARNESS_VERSION = 'h16-coordinator-only-prewarm';
 const DYNAMIC_WORKER_BUNDLED_CODE_CACHE_MAX_ENTRIES = 64;
 const dynamicWorkerBundledCodeCache = new Map<string, string>();
 

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

@@ -106,7 +106,6 @@ import {
 // re-bundle harness internals into per-play. Keep that in mind.
 import {
   harnessPersistCompletedSheetRows,
-  harnessPrewarmPostgresSessions,
   harnessReadSheetDatasetRows,
   harnessReadStagedFileChunk,
   harnessStartSheetDataset,
@@ -568,7 +567,11 @@ async function postRuntimeApi<T>(
   // hits the same handler with the same auth — only the transport changes.
   const serializedBody = JSON.stringify(body);
   let lastError: unknown = null;
-  for (let attempt = 0; attempt <= RUNTIME_API_RETRY_DELAYS_MS.length; attempt += 1) {
+  for (
+    let attempt = 0;
+    attempt <= RUNTIME_API_RETRY_DELAYS_MS.length;
+    attempt += 1
+  ) {
     let res: Response;
     try {
       res = await fetchRuntimeApi(baseUrl, '/api/v2/plays/internal/runtime', {
@@ -618,7 +621,13 @@ function isRetryableRuntimeApiError(error: unknown): boolean {
 }
 
 function isRetryableRuntimeApiResponse(status: number, body: string): boolean {
-  if (status === 408 || status === 429 || status === 502 || status === 503 || status === 504) {
+  if (
+    status === 408 ||
+    status === 429 ||
+    status === 502 ||
+    status === 503 ||
+    status === 504
+  ) {
     return true;
   }
   return (
@@ -2465,7 +2474,10 @@ function readHarnessStagedFileChunks(input: {
       }
 
       const requiredBytes = expectedBytes ?? objectSize;
-      if (typeof requiredBytes === 'number' && observedBytes !== requiredBytes) {
+      if (
+        typeof requiredBytes === 'number' &&
+        observedBytes !== requiredBytes
+      ) {
         recordRunnerPerfTrace({
           req: input.req,
           phase: 'csv.read_mismatch',
@@ -2761,6 +2773,28 @@ async function prepareMapRows(input: {
     userEmail: input.req.userEmail,
     preloadedDbSessions: input.req.preloadedDbSessions ?? null,
   });
+  for (const timing of result.timings ?? []) {
+    const phase =
+      typeof timing.phase === 'string' && timing.phase.trim()
+        ? timing.phase.trim()
+        : 'unknown';
+    const ms =
+      typeof timing.ms === 'number' && Number.isFinite(timing.ms)
+        ? timing.ms
+        : 0;
+    const { phase: _phase, ms: _ms, ...extra } = timing;
+    void _phase;
+    void _ms;
+    recordRunnerPerfTrace({
+      req: input.req,
+      phase: `sheet_start.${phase}`,
+      ms,
+      extra: {
+        tableNamespace: input.tableNamespace,
+        ...extra,
+      },
+    });
+  }
   return {
     inserted: result.inserted,
     skipped: result.skipped,
@@ -3717,7 +3751,8 @@ function createMinimalWorkerCtx(
         if (matchByPath) {
           file = {
             logicalPath: matchByPath.playPath,
-            fileName: matchByPath.playPath.split('/').pop() ?? matchByPath.playPath,
+            fileName:
+              matchByPath.playPath.split('/').pop() ?? matchByPath.playPath,
             storageKey: matchByPath.storageKey,
             contentType: matchByPath.contentType,
             bytes: matchByPath.bytes,
@@ -4245,19 +4280,6 @@ async function executeRunRequest(
   });
   const abortController = options?.abortController ?? new AbortController();
   const abortSignal = abortController.signal;
-  const postgresPrewarmStartedAt = nowMs();
-  await harnessPrewarmPostgresSessions({
-    executorToken: req.executorToken,
-    sessions: req.preloadedDbSessions ?? [],
-  });
-  recordRunnerPerfTrace({
-    req,
-    phase: 'runner.prewarm_postgres',
-    ms: nowMs() - postgresPrewarmStartedAt,
-    extra: {
-      sessions: req.preloadedDbSessions?.length ?? 0,
-    },
-  });
   let runLogBuffer: string[] = [];
   let pendingRunLogLines: string[] = [];
   let stepProgressByNodeId: LiveNodeProgressMap = {};
@@ -4427,6 +4449,11 @@ async function executeRunRequest(
     if (!options?.persistResultDatasets) return;
     await ledgerFlushInFlight.catch(() => undefined);
     const now = nowMs();
+    pendingRunLogLines = runLogBuffer;
+    dirtyProgressNodeIds = new Set([
+      ...dirtyProgressNodeIds,
+      ...Object.keys(stepProgressByNodeId),
+    ]);
     pendingLedgerEvents = [...pendingLedgerEvents, terminalEvent];
     const events = drainPendingLedgerEvents(now);
     if (events.length === 0) return;
@@ -4510,12 +4537,12 @@ async function executeRunRequest(
       ms: nowMs() - serializeStartedAt,
     });
     if (options?.persistResultDatasets) {
-      const persistStartedAt = nowMs();
+      const ledgerFlushWaitStartedAt = nowMs();
       await ledgerFlushInFlight.catch(() => undefined);
       recordRunnerPerfTrace({
         req,
         phase: 'runner.run_ledger_flush_wait',
-        ms: nowMs() - persistStartedAt,
+        ms: nowMs() - ledgerFlushWaitStartedAt,
       });
       const resultDatasetStartedAt = nowMs();
       await persistResultDatasets(req, result, serializedResult);
@@ -4526,31 +4553,58 @@ async function executeRunRequest(
       });
       const terminalResult = trimResultForStatus(serializedResult);
       const terminalOccurredAt = nowMs();
+      const terminalLedgerPromise = (async () => {
+        const terminalUpdateStartedAt = nowMs();
+        await flushTerminalLedgerEvents({
+          type: 'run.completed',
+          runId: req.runId,
+          source: 'worker',
+          occurredAt: terminalOccurredAt,
+          result: terminalResult,
+        });
+        recordRunnerPerfTrace({
+          req,
+          phase: 'runner.terminal_ledger_append',
+          ms: nowMs() - terminalUpdateStartedAt,
+        });
+      })().catch((error) => {
+        console.error(
+          `[play-harness] non-fatal terminal ledger append failed runId=${req.runId}: ${
+            error instanceof Error ? error.message : String(error)
+          }`,
+        );
+      });
+
+      await terminalLedgerPromise;
+
       const billingStartedAt = nowMs();
-      await finalizeWorkerComputeBilling({
+      const billingPromise = finalizeWorkerComputeBilling({
         req,
         success: true,
         actionEstimate: 4,
+      }).then(() => {
+        recordRunnerPerfTrace({
+          req,
+          phase: 'runner.compute_billing_finalize',
+          ms: nowMs() - billingStartedAt,
+        });
       });
-      recordRunnerPerfTrace({
-        req,
-        phase: 'runner.compute_billing_finalize',
-        ms: nowMs() - billingStartedAt,
-      });
-
-      const terminalUpdateStartedAt = nowMs();
-      await flushTerminalLedgerEvents({
-        type: 'run.completed',
-        runId: req.runId,
-        source: 'worker',
-        occurredAt: terminalOccurredAt,
-        result: terminalResult,
-      });
-      recordRunnerPerfTrace({
-        req,
-        phase: 'runner.terminal_ledger_append',
-        ms: nowMs() - terminalUpdateStartedAt,
-      });
+      if (extractMaxCreditsPerRun(req.contractSnapshot) !== null) {
+        await billingPromise;
+      } else {
+        const nonBlockingBillingPromise = billingPromise.catch((error) => {
+          console.error(
+            `[play-harness] non-fatal compute billing finalize failed runId=${req.runId}: ${
+              error instanceof Error ? error.message : String(error)
+            }`,
+          );
+        });
+        if (options?.waitUntil) {
+          options.waitUntil(nonBlockingBillingPromise);
+        } else {
+          await nonBlockingBillingPromise;
+        }
+      }
     }
     const parentSignalStartedAt = nowMs();
     await signalParentPlayTerminal({
@@ -4713,7 +4767,9 @@ function runRequestFromWorkflowParams(
       inputFile && inputStorageKey
         ? {
             [fileName]: {
-              logicalPath: String(inputFile.logicalPath ?? inputFile.path ?? fileName),
+              logicalPath: String(
+                inputFile.logicalPath ?? inputFile.path ?? fileName,
+              ),
               fileName,
               storageKey: inputStorageKey,
               contentType:
@@ -5255,7 +5311,10 @@ function inferOutputRows(result: unknown): number {
     }
     if (typeof value !== 'object') return;
     const record = value as Record<string, unknown>;
-    if (typeof record.tableNamespace === 'string' && typeof record.count === 'number') {
+    if (
+      typeof record.tableNamespace === 'string' &&
+      typeof record.count === 'number'
+    ) {
       datasets.push(record.count);
     }
     for (const [key, child] of Object.entries(record)) {

package/dist/repo/sdk/src/plays/harness-stub.ts

@@ -8,13 +8,11 @@
  *
  * What it does:
  *   - Exposes thin functions that look like the in-bundle implementations
- *     they're replacing (validate, runtime-api call, …).
+ *     they're replacing (runtime-api call, staged dataset IO, …).
  *   - Each function calls `env.HARNESS.<method>(...)` — the typed RPC
  *     stub provided by the Cloudflare service binding.
  *
  * What it does NOT do:
- *   - Does NOT import zod (that's the whole point — zod stays in the
- *     harness Worker).
  *   - Does NOT import the harness Worker's `PlayHarness` class (that
  *     would re-bundle the whole harness; only TYPES are imported).
  *   - Does NOT cache RPC results across plays — caching belongs to
@@ -36,12 +34,10 @@ import type {
   PreloadedRuntimeDbSessionInput,
   RuntimeApiCallInput,
   RuntimeApiCallResult,
-  RuntimePayloadSchemaId,
   SheetDatasetRowsInput,
   SheetDatasetRowsResult,
   StagedFileChunkInput,
   StagedFileChunkResult,
-  ValidatePayloadResult,
 } from '../../../apps/play-harness-worker/src/rpc-types';
 
 /**
@@ -173,6 +169,7 @@ export async function harnessStartSheetDataset(input: {
   pendingRows: Array<Record<string, unknown>>;
   completedRows: Array<Record<string, unknown>>;
   tableNamespace: string;
+  timings?: Array<Record<string, unknown>>;
 }> {
   return requireBinding().startSheetDataset(input);
 }
@@ -195,18 +192,3 @@ export async function harnessPersistCompletedSheetRows(input: {
 }): Promise<{ ok: true; rowsWritten: number; tableNamespace: string }> {
   return requireBinding().persistCompletedMapRows(input);
 }
-
-/**
- * Validate a payload against a named schema. The schema definitions
- * (and zod itself) live in the harness Worker — see
- * `apps/play-harness-worker/src/leaves/validate.ts → KNOWN_SCHEMAS`.
- *
- * Use a schema id of the form `tool:<provider>:<operation>` for tool
- * inputs, or `runtime-api:<action>` for runtime-api request bodies.
- */
-export async function harnessValidatePayload(
-  schemaId: RuntimePayloadSchemaId,
-  payload: unknown,
-): Promise<ValidatePayloadResult> {
-  return requireBinding().validatePayload({ schemaId, payload });
-}

package/dist/repo/sdk/src/version.ts

@@ -1,2 +1,2 @@
-export const SDK_VERSION = "0.1.26";
+export const SDK_VERSION = "0.1.27";
 export const SDK_API_CONTRACT = "2026-05-runs-v2";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepline",
-  "version": "0.1.26",
+  "version": "0.1.27",
   "description": "Deepline SDK + CLI — B2B data enrichment powered by durable cloud execution",
   "license": "MIT",
   "repository": {